\"), nil\n\t}\n\n\tif wrapTextMarshalV2 {\n\t\tif m, ok := m.(encoding.TextMarshaler); ok {\n\t\t\treturn m.MarshalText()\n\t\t}\n\n\t\topts := prototext.MarshalOptions{\n\t\t\tAllowPartial: true,\n\t\t\tEmitUnknown: true,\n\t\t}\n\t\tif !tm.Compact {\n\t\t\topts.Indent = \" \"\n\t\t}\n\t\tif !tm.ExpandAny {\n\t\t\topts.Resolver = (*protoregistry.Types)(nil)\n\t\t}\n\t\treturn opts.Marshal(mr.Interface())\n\t} else {\n\t\tw := &textWriter{\n\t\t\tcompact: tm.Compact,\n\t\t\texpandAny: tm.ExpandAny,\n\t\t\tcomplete: true,\n\t\t}\n\n\t\tif m, ok := m.(encoding.TextMarshaler); ok {\n\t\t\tb, err := m.MarshalText()\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tw.Write(b)\n\t\t\treturn w.buf, nil\n\t\t}\n\n\t\terr := w.writeMessage(mr)\n\t\treturn w.buf, err\n\t}\n}\n\nvar (\n\tdefaultTextMarshaler = TextMarshaler{}\n\tcompactTextMarshaler = TextMarshaler{Compact: true}\n)\n\n// MarshalText writes the proto text format of m to w.\nfunc MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }\n\n// MarshalTextString returns a proto text formatted string of m.\nfunc MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }\n\n// CompactText writes the compact proto text format of m to w.\nfunc CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }\n\n// CompactTextString returns a compact proto text formatted string of m.\nfunc CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }\n\nvar (\n\tnewline = []byte(\"\\n\")\n\tendBraceNewline = []byte(\"}\\n\")\n\tposInf = []byte(\"inf\")\n\tnegInf = []byte(\"-inf\")\n\tnan = []byte(\"nan\")\n)\n\n// textWriter is an io.Writer that tracks its indentation level.\ntype textWriter struct {\n\tcompact bool // same as TextMarshaler.Compact\n\texpandAny bool // same as TextMarshaler.ExpandAny\n\tcomplete bool // whether the current position is a complete line\n\tindent int // indentation level; never negative\n\tbuf []byte\n}\n\nfunc (w *textWriter) Write(p []byte) (n int, _ error) {\n\tnewlines := bytes.Count(p, newline)\n\tif newlines == 0 {\n\t\tif !w.compact && w.complete {\n\t\t\tw.writeIndent()\n\t\t}\n\t\tw.buf = append(w.buf, p...)\n\t\tw.complete = false\n\t\treturn len(p), nil\n\t}\n\n\tfrags := bytes.SplitN(p, newline, newlines+1)\n\tif w.compact {\n\t\tfor i, frag := range frags {\n\t\t\tif i > 0 {\n\t\t\t\tw.buf = append(w.buf, ' ')\n\t\t\t\tn++\n\t\t\t}\n\t\t\tw.buf = append(w.buf, frag...)\n\t\t\tn += len(frag)\n\t\t}\n\t\treturn n, nil\n\t}\n\n\tfor i, frag := range frags {\n\t\tif w.complete {\n\t\t\tw.writeIndent()\n\t\t}\n\t\tw.buf = append(w.buf, frag...)\n\t\tn += len(frag)\n\t\tif i+1 < len(frags) {\n\t\t\tw.buf = append(w.buf, '\\n')\n\t\t\tn++\n\t\t}\n\t}\n\tw.complete = len(frags[len(frags)-1]) == 0\n\treturn n, nil\n}\n\nfunc (w *textWriter) WriteByte(c byte) error {\n\tif w.compact && c == '\\n' {\n\t\tc = ' '\n\t}\n\tif !w.compact && w.complete {\n\t\tw.writeIndent()\n\t}\n\tw.buf = append(w.buf, c)\n\tw.complete = c == '\\n'\n\treturn nil\n}\n\nfunc (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {\n\tif !w.compact && w.complete {\n\t\tw.writeIndent()\n\t}\n\tw.complete = false\n\n\tif fd.Kind() != protoreflect.GroupKind {\n\t\tw.buf = append(w.buf, fd.Name()...)\n\t\tw.WriteByte(':')\n\t} else {\n\t\t// Use message type name for group field name.\n\t\tw.buf = append(w.buf, fd.Message().Name()...)\n\t}\n\n\tif !w.compact {\n\t\tw.WriteByte(' ')\n\t}\n}\n\nfunc requiresQuotes(u string) bool {\n\t// When type URL contains any characters except [0-9A-Za-z./\\-]*, it must be quoted.\n\tfor _, ch := range u {\n\t\tswitch {\n\t\tcase ch == '.' || ch == '/' || ch == '_':\n\t\t\tcontinue\n\t\tcase '0' <= ch && ch <= '9':\n\t\t\tcontinue\n\t\tcase 'A' <= ch && ch <= 'Z':\n\t\t\tcontinue\n\t\tcase 'a' <= ch && ch <= 'z':\n\t\t\tcontinue\n\t\tdefault:\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// writeProto3Any writes an expanded google.protobuf.Any message.\n//\n// It returns (false, nil) if sv value can't be unmarshaled (e.g. because\n// required messages are not linked in).\n//\n// It returns (true, error) when sv was written in expanded format or an error\n// was encountered.\nfunc (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {\n\tmd := m.Descriptor()\n\tfdURL := md.Fields().ByName(\"type_url\")\n\tfdVal := md.Fields().ByName(\"value\")\n\n\turl := m.Get(fdURL).String()\n\tmt, err := protoregistry.GlobalTypes.FindMessageByURL(url)\n\tif err != nil {\n\t\treturn false, nil\n\t}\n\n\tb := m.Get(fdVal).Bytes()\n\tm2 := mt.New()\n\tif err := proto.Unmarshal(b, m2.Interface()); err != nil {\n\t\treturn false, nil\n\t}\n\tw.Write([]byte(\"[\"))\n\tif requiresQuotes(url) {\n\t\tw.writeQuotedString(url)\n\t} else {\n\t\tw.Write([]byte(url))\n\t}\n\tif w.compact {\n\t\tw.Write([]byte(\"]:<\"))\n\t} else {\n\t\tw.Write([]byte(\"]: <\\n\"))\n\t\tw.indent++\n\t}\n\tif err := w.writeMessage(m2); err != nil {\n\t\treturn true, err\n\t}\n\tif w.compact {\n\t\tw.Write([]byte(\"> \"))\n\t} else {\n\t\tw.indent--\n\t\tw.Write([]byte(\">\\n\"))\n\t}\n\treturn true, nil\n}\n\nfunc (w *textWriter) writeMessage(m protoreflect.Message) error {\n\tmd := m.Descriptor()\n\tif w.expandAny && md.FullName() == \"google.protobuf.Any\" {\n\t\tif canExpand, err := w.writeProto3Any(m); canExpand {\n\t\t\treturn err\n\t\t}\n\t}\n\n\tfds := md.Fields()\n\tfor i := 0; i < fds.Len(); {\n\t\tfd := fds.Get(i)\n\t\tif od := fd.ContainingOneof(); od != nil {\n\t\t\tfd = m.WhichOneof(od)\n\t\t\ti += od.Fields().Len()\n\t\t} else {\n\t\t\ti++\n\t\t}\n\t\tif fd == nil || !m.Has(fd) {\n\t\t\tcontinue\n\t\t}\n\n\t\tswitch {\n\t\tcase fd.IsList():\n\t\t\tlv := m.Get(fd).List()\n\t\t\tfor j := 0; j < lv.Len(); j++ {\n\t\t\t\tw.writeName(fd)\n\t\t\t\tv := lv.Get(j)\n\t\t\t\tif err := w.writeSingularValue(v, fd); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\tw.WriteByte('\\n')\n\t\t\t}\n\t\tcase fd.IsMap():\n\t\t\tkfd := fd.MapKey()\n\t\t\tvfd := fd.MapValue()\n\t\t\tmv := m.Get(fd).Map()\n\n\t\t\ttype entry struct{ key, val protoreflect.Value }\n\t\t\tvar entries []entry\n\t\t\tmv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {\n\t\t\t\tentries = append(entries, entry{k.Value(), v})\n\t\t\t\treturn true\n\t\t\t})\n\t\t\tsort.Slice(entries, func(i, j int) bool {\n\t\t\t\tswitch kfd.Kind() {\n\t\t\t\tcase protoreflect.BoolKind:\n\t\t\t\t\treturn !entries[i].key.Bool() && entries[j].key.Bool()\n\t\t\t\tcase protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:\n\t\t\t\t\treturn entries[i].key.Int() < entries[j].key.Int()\n\t\t\t\tcase protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:\n\t\t\t\t\treturn entries[i].key.Uint() < entries[j].key.Uint()\n\t\t\t\tcase protoreflect.StringKind:\n\t\t\t\t\treturn entries[i].key.String() < entries[j].key.String()\n\t\t\t\tdefault:\n\t\t\t\t\tpanic(\"invalid kind\")\n\t\t\t\t}\n\t\t\t})\n\t\t\tfor _, entry := range entries {\n\t\t\t\tw.writeName(fd)\n\t\t\t\tw.WriteByte('<')\n\t\t\t\tif !w.compact {\n\t\t\t\t\tw.WriteByte('\\n')\n\t\t\t\t}\n\t\t\t\tw.indent++\n\t\t\t\tw.writeName(kfd)\n\t\t\t\tif err := w.writeSingularValue(entry.key, kfd); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\tw.WriteByte('\\n')\n\t\t\t\tw.writeName(vfd)\n\t\t\t\tif err := w.writeSingularValue(entry.val, vfd); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\tw.WriteByte('\\n')\n\t\t\t\tw.indent--\n\t\t\t\tw.WriteByte('>')\n\t\t\t\tw.WriteByte('\\n')\n\t\t\t}\n\t\tdefault:\n\t\t\tw.writeName(fd)\n\t\t\tif err := w.writeSingularValue(m.Get(fd), fd); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tw.WriteByte('\\n')\n\t\t}\n\t}\n\n\tif b := m.GetUnknown(); len(b) > 0 {\n\t\tw.writeUnknownFields(b)\n\t}\n\treturn w.writeExtensions(m)\n}\n\nfunc (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {\n\tswitch fd.Kind() {\n\tcase protoreflect.FloatKind, protoreflect.DoubleKind:\n\t\tswitch vf := v.Float(); {\n\t\tcase math.IsInf(vf, +1):\n\t\t\tw.Write(posInf)\n\t\tcase math.IsInf(vf, -1):\n\t\t\tw.Write(negInf)\n\t\tcase math.IsNaN(vf):\n\t\t\tw.Write(nan)\n\t\tdefault:\n\t\t\tfmt.Fprint(w, v.Interface())\n\t\t}\n\tcase protoreflect.StringKind:\n\t\t// NOTE: This does not validate UTF-8 for historical reasons.\n\t\tw.writeQuotedString(string(v.String()))\n\tcase protoreflect.BytesKind:\n\t\tw.writeQuotedString(string(v.Bytes()))\n\tcase protoreflect.MessageKind, protoreflect.GroupKind:\n\t\tvar bra, ket byte = '<', '>'\n\t\tif fd.Kind() == protoreflect.GroupKind {\n\t\t\tbra, ket = '{', '}'\n\t\t}\n\t\tw.WriteByte(bra)\n\t\tif !w.compact {\n\t\t\tw.WriteByte('\\n')\n\t\t}\n\t\tw.indent++\n\t\tm := v.Message()\n\t\tif m2, ok := m.Interface().(encoding.TextMarshaler); ok {\n\t\t\tb, err := m2.MarshalText()\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tw.Write(b)\n\t\t} else {\n\t\t\tw.writeMessage(m)\n\t\t}\n\t\tw.indent--\n\t\tw.WriteByte(ket)\n\tcase protoreflect.EnumKind:\n\t\tif ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {\n\t\t\tfmt.Fprint(w, ev.Name())\n\t\t} else {\n\t\t\tfmt.Fprint(w, v.Enum())\n\t\t}\n\tdefault:\n\t\tfmt.Fprint(w, v.Interface())\n\t}\n\treturn nil\n}\n\n// writeQuotedString writes a quoted string in the protocol buffer text format.\nfunc (w *textWriter) writeQuotedString(s string) {\n\tw.WriteByte('\"')\n\tfor i := 0; i < len(s); i++ {\n\t\tswitch c := s[i]; c {\n\t\tcase '\\n':\n\t\t\tw.buf = append(w.buf, `\\n`...)\n\t\tcase '\\r':\n\t\t\tw.buf = append(w.buf, `\\r`...)\n\t\tcase '\\t':\n\t\t\tw.buf = append(w.buf, `\\t`...)\n\t\tcase '\"':\n\t\t\tw.buf = append(w.buf, `\\\"`...)\n\t\tcase '\\\\':\n\t\t\tw.buf = append(w.buf, `\\\\`...)\n\t\tdefault:\n\t\t\tif isPrint := c >= 0x20 && c < 0x7f; isPrint {\n\t\t\t\tw.buf = append(w.buf, c)\n\t\t\t} else {\n\t\t\t\tw.buf = append(w.buf, fmt.Sprintf(`\\%03o`, c)...)\n\t\t\t}\n\t\t}\n\t}\n\tw.WriteByte('\"')\n}\n\nfunc (w *textWriter) writeUnknownFields(b []byte) {\n\tif !w.compact {\n\t\tfmt.Fprintf(w, \"/* %d unknown bytes */\\n\", len(b))\n\t}\n\n\tfor len(b) > 0 {\n\t\tnum, wtyp, n := protowire.ConsumeTag(b)\n\t\tif n < 0 {\n\t\t\treturn\n\t\t}\n\t\tb = b[n:]\n\n\t\tif wtyp == protowire.EndGroupType {\n\t\t\tw.indent--\n\t\t\tw.Write(endBraceNewline)\n\t\t\tcontinue\n\t\t}\n\t\tfmt.Fprint(w, num)\n\t\tif wtyp != protowire.StartGroupType {\n\t\t\tw.WriteByte(':')\n\t\t}\n\t\tif !w.compact || wtyp == protowire.StartGroupType {\n\t\t\tw.WriteByte(' ')\n\t\t}\n\t\tswitch wtyp {\n\t\tcase protowire.VarintType:\n\t\t\tv, n := protowire.ConsumeVarint(b)\n\t\t\tif n < 0 {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tb = b[n:]\n\t\t\tfmt.Fprint(w, v)\n\t\tcase protowire.Fixed32Type:\n\t\t\tv, n := protowire.ConsumeFixed32(b)\n\t\t\tif n < 0 {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tb = b[n:]\n\t\t\tfmt.Fprint(w, v)\n\t\tcase protowire.Fixed64Type:\n\t\t\tv, n := protowire.ConsumeFixed64(b)\n\t\t\tif n < 0 {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tb = b[n:]\n\t\t\tfmt.Fprint(w, v)\n\t\tcase protowire.BytesType:\n\t\t\tv, n := protowire.ConsumeBytes(b)\n\t\t\tif n < 0 {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tb = b[n:]\n\t\t\tfmt.Fprintf(w, \"%q\", v)\n\t\tcase protowire.StartGroupType:\n\t\t\tw.WriteByte('{')\n\t\t\tw.indent++\n\t\tdefault:\n\t\t\tfmt.Fprintf(w, \"/* unknown wire type %d */\", wtyp)\n\t\t}\n\t\tw.WriteByte('\\n')\n\t}\n}\n\n// writeExtensions writes all the extensions in m.\nfunc (w *textWriter) writeExtensions(m protoreflect.Message) error {\n\tmd := m.Descriptor()\n\tif md.ExtensionRanges().Len() == 0 {\n\t\treturn nil\n\t}\n\n\ttype ext struct {\n\t\tdesc protoreflect.FieldDescriptor\n\t\tval protoreflect.Value\n\t}\n\tvar exts []ext\n\tm.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {\n\t\tif fd.IsExtension() {\n\t\t\texts = append(exts, ext{fd, v})\n\t\t}\n\t\treturn true\n\t})\n\tsort.Slice(exts, func(i, j int) bool {\n\t\treturn exts[i].desc.Number() < exts[j].desc.Number()\n\t})\n\n\tfor _, ext := range exts {\n\t\t// For message set, use the name of the message as the extension name.\n\t\tname := string(ext.desc.FullName())\n\t\tif isMessageSet(ext.desc.ContainingMessage()) {\n\t\t\tname = strings.TrimSuffix(name, \".message_set_extension\")\n\t\t}\n\n\t\tif !ext.desc.IsList() {\n\t\t\tif err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t} else {\n\t\t\tlv := ext.val.List()\n\t\t\tfor i := 0; i < lv.Len(); i++ {\n\t\t\t\tif err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {\n\tfmt.Fprintf(w, \"[%s]:\", name)\n\tif !w.compact {\n\t\tw.WriteByte(' ')\n\t}\n\tif err := w.writeSingularValue(v, fd); err != nil {\n\t\treturn err\n\t}\n\tw.WriteByte('\\n')\n\treturn nil\n}\n\nfunc (w *textWriter) writeIndent() {\n\tif !w.complete {\n\t\treturn\n\t}\n\tfor i := 0; i < w.indent*2; i++ {\n\t\tw.buf = append(w.buf, ' ')\n\t}\n\tw.complete = false\n}\n"
},
{
"path": "vendor/github.com/golang/protobuf/proto/wire.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage proto\n\nimport (\n\tprotoV2 \"google.golang.org/protobuf/proto\"\n\t\"google.golang.org/protobuf/runtime/protoiface\"\n)\n\n// Size returns the size in bytes of the wire-format encoding of m.\nfunc Size(m Message) int {\n\tif m == nil {\n\t\treturn 0\n\t}\n\tmi := MessageV2(m)\n\treturn protoV2.Size(mi)\n}\n\n// Marshal returns the wire-format encoding of m.\nfunc Marshal(m Message) ([]byte, error) {\n\tb, err := marshalAppend(nil, m, false)\n\tif b == nil {\n\t\tb = zeroBytes\n\t}\n\treturn b, err\n}\n\nvar zeroBytes = make([]byte, 0, 0)\n\nfunc marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) {\n\tif m == nil {\n\t\treturn nil, ErrNil\n\t}\n\tmi := MessageV2(m)\n\tnbuf, err := protoV2.MarshalOptions{\n\t\tDeterministic: deterministic,\n\t\tAllowPartial: true,\n\t}.MarshalAppend(buf, mi)\n\tif err != nil {\n\t\treturn buf, err\n\t}\n\tif len(buf) == len(nbuf) {\n\t\tif !mi.ProtoReflect().IsValid() {\n\t\t\treturn buf, ErrNil\n\t\t}\n\t}\n\treturn nbuf, checkRequiredNotSet(mi)\n}\n\n// Unmarshal parses a wire-format message in b and places the decoded results in m.\n//\n// Unmarshal resets m before starting to unmarshal, so any existing data in m is always\n// removed. Use UnmarshalMerge to preserve and append to existing data.\nfunc Unmarshal(b []byte, m Message) error {\n\tm.Reset()\n\treturn UnmarshalMerge(b, m)\n}\n\n// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.\nfunc UnmarshalMerge(b []byte, m Message) error {\n\tmi := MessageV2(m)\n\tout, err := protoV2.UnmarshalOptions{\n\t\tAllowPartial: true,\n\t\tMerge: true,\n\t}.UnmarshalState(protoiface.UnmarshalInput{\n\t\tBuf: b,\n\t\tMessage: mi.ProtoReflect(),\n\t})\n\tif err != nil {\n\t\treturn err\n\t}\n\tif out.Flags&protoiface.UnmarshalInitialized > 0 {\n\t\treturn nil\n\t}\n\treturn checkRequiredNotSet(mi)\n}\n"
},
{
"path": "vendor/github.com/golang/protobuf/proto/wrappers.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage proto\n\n// Bool stores v in a new bool value and returns a pointer to it.\nfunc Bool(v bool) *bool { return &v }\n\n// Int stores v in a new int32 value and returns a pointer to it.\n//\n// Deprecated: Use Int32 instead.\nfunc Int(v int) *int32 { return Int32(int32(v)) }\n\n// Int32 stores v in a new int32 value and returns a pointer to it.\nfunc Int32(v int32) *int32 { return &v }\n\n// Int64 stores v in a new int64 value and returns a pointer to it.\nfunc Int64(v int64) *int64 { return &v }\n\n// Uint32 stores v in a new uint32 value and returns a pointer to it.\nfunc Uint32(v uint32) *uint32 { return &v }\n\n// Uint64 stores v in a new uint64 value and returns a pointer to it.\nfunc Uint64(v uint64) *uint64 { return &v }\n\n// Float32 stores v in a new float32 value and returns a pointer to it.\nfunc Float32(v float32) *float32 { return &v }\n\n// Float64 stores v in a new float64 value and returns a pointer to it.\nfunc Float64(v float64) *float64 { return &v }\n\n// String stores v in a new string value and returns a pointer to it.\nfunc String(v string) *string { return &v }\n"
},
{
"path": "vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go",
"content": "// Code generated by protoc-gen-go. DO NOT EDIT.\n// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto\n\npackage timestamp\n\nimport (\n\tprotoreflect \"google.golang.org/protobuf/reflect/protoreflect\"\n\tprotoimpl \"google.golang.org/protobuf/runtime/protoimpl\"\n\ttimestamppb \"google.golang.org/protobuf/types/known/timestamppb\"\n\treflect \"reflect\"\n)\n\n// Symbols defined in public import of google/protobuf/timestamp.proto.\n\ntype Timestamp = timestamppb.Timestamp\n\nvar File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor\n\nvar file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{\n\t0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,\n\t0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,\n\t0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,\n\t0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67,\n\t0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74,\n\t0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37,\n\t0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,\n\t0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,\n\t0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,\n\t0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,\n\t0x33,\n}\n\nvar file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}\nvar file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{\n\t0, // [0:0] is the sub-list for method output_type\n\t0, // [0:0] is the sub-list for method input_type\n\t0, // [0:0] is the sub-list for extension type_name\n\t0, // [0:0] is the sub-list for extension extendee\n\t0, // [0:0] is the sub-list for field type_name\n}\n\nfunc init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }\nfunc file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {\n\tif File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {\n\t\treturn\n\t}\n\ttype x struct{}\n\tout := protoimpl.TypeBuilder{\n\t\tFile: protoimpl.DescBuilder{\n\t\t\tGoPackagePath: reflect.TypeOf(x{}).PkgPath(),\n\t\t\tRawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,\n\t\t\tNumEnums: 0,\n\t\t\tNumMessages: 0,\n\t\t\tNumExtensions: 0,\n\t\t\tNumServices: 0,\n\t\t},\n\t\tGoTypes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,\n\t\tDependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,\n\t}.Build()\n\tFile_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File\n\tfile_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil\n\tfile_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil\n\tfile_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/.gitignore",
"content": ".DS_Store\nbin\n.idea/\n\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/LICENSE",
"content": "Copyright (c) 2012 Dave Grijalva\nCopyright (c) 2021 golang-jwt maintainers\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/MIGRATION_GUIDE.md",
"content": "## Migration Guide (v4.0.0)\n\nStarting from [v4.0.0](https://github.com/golang-jwt/jwt/releases/tag/v4.0.0), the import path will be:\n\n \"github.com/golang-jwt/jwt/v4\"\n\nThe `/v4` version will be backwards compatible with existing `v3.x.y` tags in this repo, as well as \n`github.com/dgrijalva/jwt-go`. For most users this should be a drop-in replacement, if you're having \ntroubles migrating, please open an issue.\n\nYou can replace all occurrences of `github.com/dgrijalva/jwt-go` or `github.com/golang-jwt/jwt` with `github.com/golang-jwt/jwt/v4`, either manually or by using tools such as `sed` or `gofmt`.\n\nAnd then you'd typically run:\n\n```\ngo get github.com/golang-jwt/jwt/v4\ngo mod tidy\n```\n\n## Older releases (before v3.2.0)\n\nThe original migration guide for older releases can be found at https://github.com/dgrijalva/jwt-go/blob/master/MIGRATION_GUIDE.md.\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/README.md",
"content": "# jwt-go\n\n[](https://github.com/golang-jwt/jwt/actions/workflows/build.yml)\n[](https://pkg.go.dev/github.com/golang-jwt/jwt/v4)\n\nA [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](https://datatracker.ietf.org/doc/html/rfc7519).\n\nStarting with [v4.0.0](https://github.com/golang-jwt/jwt/releases/tag/v4.0.0) this project adds Go module support, but maintains backwards compatibility with older `v3.x.y` tags and upstream `github.com/dgrijalva/jwt-go`.\nSee the [`MIGRATION_GUIDE.md`](./MIGRATION_GUIDE.md) for more information.\n\n> After the original author of the library suggested migrating the maintenance of `jwt-go`, a dedicated team of open source maintainers decided to clone the existing library into this repository. See [dgrijalva/jwt-go#462](https://github.com/dgrijalva/jwt-go/issues/462) for a detailed discussion on this topic.\n\n\n**SECURITY NOTICE:** Some older versions of Go have a security issue in the crypto/elliptic. Recommendation is to upgrade to at least 1.15 See issue [dgrijalva/jwt-go#216](https://github.com/dgrijalva/jwt-go/issues/216) for more detail.\n\n**SECURITY NOTICE:** It's important that you [validate the `alg` presented is what you expect](https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/). This library attempts to make it easy to do the right thing by requiring key types match the expected alg, but you should take the extra step to verify it in your usage. See the examples provided.\n\n### Supported Go versions\n\nOur support of Go versions is aligned with Go's [version release policy](https://golang.org/doc/devel/release#policy).\nSo we will support a major version of Go until there are two newer major releases.\nWe no longer support building jwt-go with unsupported Go versions, as these contain security vulnerabilities\nwhich will not be fixed.\n\n## What the heck is a JWT?\n\nJWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens.\n\nIn short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used for `Bearer` tokens in Oauth 2. A token is made of three parts, separated by `.`'s. The first two parts are JSON objects, that have been [base64url](https://datatracker.ietf.org/doc/html/rfc4648) encoded. The last part is the signature, encoded the same way.\n\nThe first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used.\n\nThe part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer to [RFC 7519](https://datatracker.ietf.org/doc/html/rfc7519) for information about reserved keys and the proper way to add your own.\n\n## What's in the box?\n\nThis library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.\n\n## Installation Guidelines\n\n1. To install the jwt package, you first need to have [Go](https://go.dev/doc/install) installed, then you can use the command below to add `jwt-go` as a dependency in your Go program.\n\n```sh\ngo get -u github.com/golang-jwt/jwt/v4\n```\n\n2. Import it in your code:\n\n```go\nimport \"github.com/golang-jwt/jwt/v4\"\n```\n\n## Examples\n\nSee [the project documentation](https://pkg.go.dev/github.com/golang-jwt/jwt/v4) for examples of usage:\n\n* [Simple example of parsing and validating a token](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#example-Parse-Hmac)\n* [Simple example of building and signing a token](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#example-New-Hmac)\n* [Directory of Examples](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#pkg-examples)\n\n## Extensions\n\nThis library publishes all the necessary components for adding your own signing methods or key functions. Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod` or provide a `jwt.Keyfunc`.\n\nA common use case would be integrating with different 3rd party signature providers, like key management services from various cloud providers or Hardware Security Modules (HSMs) or to implement additional standards.\n\n| Extension | Purpose | Repo |\n| --------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------ |\n| GCP | Integrates with multiple Google Cloud Platform signing tools (AppEngine, IAM API, Cloud KMS) | https://github.com/someone1/gcp-jwt-go |\n| AWS | Integrates with AWS Key Management Service, KMS | https://github.com/matelang/jwt-go-aws-kms |\n| JWKS | Provides support for JWKS ([RFC 7517](https://datatracker.ietf.org/doc/html/rfc7517)) as a `jwt.Keyfunc` | https://github.com/MicahParks/keyfunc |\n\n*Disclaimer*: Unless otherwise specified, these integrations are maintained by third parties and should not be considered as a primary offer by any of the mentioned cloud providers\n\n## Compliance\n\nThis library was last reviewed to comply with [RFC 7519](https://datatracker.ietf.org/doc/html/rfc7519) dated May 2015 with a few notable differences:\n\n* In order to protect against accidental use of [Unsecured JWTs](https://datatracker.ietf.org/doc/html/rfc7519#section-6), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key.\n\n## Project Status & Versioning\n\nThis library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).\n\nThis project uses [Semantic Versioning 2.0.0](http://semver.org). Accepted pull requests will land on `main`. Periodically, versions will be tagged from `main`. You can find all the releases on [the project releases page](https://github.com/golang-jwt/jwt/releases).\n\n**BREAKING CHANGES:*** \nA full list of breaking changes is available in `VERSION_HISTORY.md`. See `MIGRATION_GUIDE.md` for more information on updating your code.\n\n## Usage Tips\n\n### Signing vs Encryption\n\nA token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:\n\n* The author of the token was in the possession of the signing secret\n* The data has not been modified since it was signed\n\nIt's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. The companion project https://github.com/golang-jwt/jwe aims at a (very) experimental implementation of the JWE standard.\n\n### Choosing a Signing Method\n\nThere are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric.\n\nSymmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.\n\nAsymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.\n\n### Signing Methods and Key Types\n\nEach signing method expects a different object type for its signing keys. See the package documentation for details. Here are the most common ones:\n\n* The [HMAC signing method](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#SigningMethodHMAC) (`HS256`,`HS384`,`HS512`) expect `[]byte` values for signing and validation\n* The [RSA signing method](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#SigningMethodRSA) (`RS256`,`RS384`,`RS512`) expect `*rsa.PrivateKey` for signing and `*rsa.PublicKey` for validation\n* The [ECDSA signing method](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#SigningMethodECDSA) (`ES256`,`ES384`,`ES512`) expect `*ecdsa.PrivateKey` for signing and `*ecdsa.PublicKey` for validation\n* The [EdDSA signing method](https://pkg.go.dev/github.com/golang-jwt/jwt/v4#SigningMethodEd25519) (`Ed25519`) expect `ed25519.PrivateKey` for signing and `ed25519.PublicKey` for validation\n\n### JWT and OAuth\n\nIt's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.\n\nWithout going too far down the rabbit hole, here's a description of the interaction of these technologies:\n\n* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.\n* OAuth defines several options for passing around authentication data. One popular method is called a \"bearer token\". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.\n* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.\n\n### Troubleshooting\n\nThis library uses descriptive error messages whenever possible. If you are not getting the expected result, have a look at the errors. The most common place people get stuck is providing the correct type of key to the parser. See the above section on signing methods and key types.\n\n## More\n\nDocumentation can be found [on pkg.go.dev](https://pkg.go.dev/github.com/golang-jwt/jwt/v4).\n\nThe command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in the documentation.\n\n[golang-jwt](https://github.com/orgs/golang-jwt) incorporates a modified version of the JWT logo, which is distributed under the terms of the [MIT License](https://github.com/jsonwebtoken/jsonwebtoken.github.io/blob/master/LICENSE.txt).\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/SECURITY.md",
"content": "# Security Policy\n\n## Supported Versions\n\nAs of February 2022 (and until this document is updated), the latest version `v4` is supported.\n\n## Reporting a Vulnerability\n\nIf you think you found a vulnerability, and even if you are not sure, please report it to jwt-go-security@googlegroups.com or one of the other [golang-jwt maintainers](https://github.com/orgs/golang-jwt/people). Please try be explicit, describe steps to reproduce the security issue with code example(s).\n\nYou will receive a response within a timely manner. If the issue is confirmed, we will do our best to release a patch as soon as possible given the complexity of the problem.\n\n## Public Discussions\n\nPlease avoid publicly discussing a potential security vulnerability.\n\nLet's take this offline and find a solution first, this limits the potential impact as much as possible.\n\nWe appreciate your help!\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/VERSION_HISTORY.md",
"content": "## `jwt-go` Version History\n\n#### 4.0.0\n\n* Introduces support for Go modules. The `v4` version will be backwards compatible with `v3.x.y`.\n\n#### 3.2.2\n\n* Starting from this release, we are adopting the policy to support the most 2 recent versions of Go currently available. By the time of this release, this is Go 1.15 and 1.16 ([#28](https://github.com/golang-jwt/jwt/pull/28)).\n* Fixed a potential issue that could occur when the verification of `exp`, `iat` or `nbf` was not required and contained invalid contents, i.e. non-numeric/date. Thanks for @thaJeztah for making us aware of that and @giorgos-f3 for originally reporting it to the formtech fork ([#40](https://github.com/golang-jwt/jwt/pull/40)).\n* Added support for EdDSA / ED25519 ([#36](https://github.com/golang-jwt/jwt/pull/36)).\n* Optimized allocations ([#33](https://github.com/golang-jwt/jwt/pull/33)).\n\n#### 3.2.1\n\n* **Import Path Change**: See MIGRATION_GUIDE.md for tips on updating your code\n\t* Changed the import path from `github.com/dgrijalva/jwt-go` to `github.com/golang-jwt/jwt`\n* Fixed type confusing issue between `string` and `[]string` in `VerifyAudience` ([#12](https://github.com/golang-jwt/jwt/pull/12)). This fixes CVE-2020-26160 \n\n#### 3.2.0\n\n* Added method `ParseUnverified` to allow users to split up the tasks of parsing and validation\n* HMAC signing method returns `ErrInvalidKeyType` instead of `ErrInvalidKey` where appropriate\n* Added options to `request.ParseFromRequest`, which allows for an arbitrary list of modifiers to parsing behavior. Initial set include `WithClaims` and `WithParser`. Existing usage of this function will continue to work as before.\n* Deprecated `ParseFromRequestWithClaims` to simplify API in the future.\n\n#### 3.1.0\n\n* Improvements to `jwt` command line tool\n* Added `SkipClaimsValidation` option to `Parser`\n* Documentation updates\n\n#### 3.0.0\n\n* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code\n\t* Dropped support for `[]byte` keys when using RSA signing methods. This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods.\n\t* `ParseFromRequest` has been moved to `request` subpackage and usage has changed\n\t* The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`. The default value is type `MapClaims`, which is an alias to `map[string]interface{}`. This makes it possible to use a custom type when decoding claims.\n* Other Additions and Changes\n\t* Added `Claims` interface type to allow users to decode the claims into a custom type\n\t* Added `ParseWithClaims`, which takes a third argument of type `Claims`. Use this function instead of `Parse` if you have a custom type you'd like to decode into.\n\t* Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage\n\t* Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims`\n\t* Added new interface type `Extractor`, which is used for extracting JWT strings from http requests. Used with `ParseFromRequest` and `ParseFromRequestWithClaims`.\n\t* Added several new, more specific, validation errors to error type bitmask\n\t* Moved examples from README to executable example files\n\t* Signing method registry is now thread safe\n\t* Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser)\n\n#### 2.7.0\n\nThis will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes.\n\n* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying\n* Error text for expired tokens includes how long it's been expired\n* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM`\n* Documentation updates\n\n#### 2.6.0\n\n* Exposed inner error within ValidationError\n* Fixed validation errors when using UseJSONNumber flag\n* Added several unit tests\n\n#### 2.5.0\n\n* Added support for signing method none. You shouldn't use this. The API tries to make this clear.\n* Updated/fixed some documentation\n* Added more helpful error message when trying to parse tokens that begin with `BEARER `\n\n#### 2.4.0\n\n* Added new type, Parser, to allow for configuration of various parsing parameters\n\t* You can now specify a list of valid signing methods. Anything outside this set will be rejected.\n\t* You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON\n* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go)\n* Fixed some bugs with ECDSA parsing\n\n#### 2.3.0\n\n* Added support for ECDSA signing methods\n* Added support for RSA PSS signing methods (requires go v1.4)\n\n#### 2.2.0\n\n* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`. Result will now be the parsed token and an error, instead of a panic.\n\n#### 2.1.0\n\nBackwards compatible API change that was missed in 2.0.0.\n\n* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte`\n\n#### 2.0.0\n\nThere were two major reasons for breaking backwards compatibility with this update. The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations. There will likely be no required code changes to support this change.\n\nThe second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods. Not all keys used for all signing methods have a single standard on-disk representation. Requiring `[]byte` as the type for all keys proved too limiting. Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys. Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`.\n\nIt is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`.\n\n* **Compatibility Breaking Changes**\n\t* `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct`\n\t* `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct`\n\t* `KeyFunc` now returns `interface{}` instead of `[]byte`\n\t* `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key\n\t* `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key\n* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`. Specific sizes are now just instances of this type.\n * Added public package global `SigningMethodHS256`\n * Added public package global `SigningMethodHS384`\n * Added public package global `SigningMethodHS512`\n* Renamed type `SigningMethodRS256` to `SigningMethodRSA`. Specific sizes are now just instances of this type.\n * Added public package global `SigningMethodRS256`\n * Added public package global `SigningMethodRS384`\n * Added public package global `SigningMethodRS512`\n* Moved sample private key for HMAC tests from an inline value to a file on disk. Value is unchanged.\n* Refactored the RSA implementation to be easier to read\n* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM`\n\n#### 1.0.2\n\n* Fixed bug in parsing public keys from certificates\n* Added more tests around the parsing of keys for RS256\n* Code refactoring in RS256 implementation. No functional changes\n\n#### 1.0.1\n\n* Fixed panic if RS256 signing method was passed an invalid key\n\n#### 1.0.0\n\n* First versioned release\n* API stabilized\n* Supports creating, signing, parsing, and validating JWT tokens\n* Supports RS256 and HS256 signing methods\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/claims.go",
"content": "package jwt\n\nimport (\n\t\"crypto/subtle\"\n\t\"fmt\"\n\t\"time\"\n)\n\n// Claims must just have a Valid method that determines\n// if the token is invalid for any supported reason\ntype Claims interface {\n\tValid() error\n}\n\n// RegisteredClaims are a structured version of the JWT Claims Set,\n// restricted to Registered Claim Names, as referenced at\n// https://datatracker.ietf.org/doc/html/rfc7519#section-4.1\n//\n// This type can be used on its own, but then additional private and\n// public claims embedded in the JWT will not be parsed. The typical usecase\n// therefore is to embedded this in a user-defined claim type.\n//\n// See examples for how to use this with your own claim types.\ntype RegisteredClaims struct {\n\t// the `iss` (Issuer) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.1\n\tIssuer string `json:\"iss,omitempty\"`\n\n\t// the `sub` (Subject) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.2\n\tSubject string `json:\"sub,omitempty\"`\n\n\t// the `aud` (Audience) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.3\n\tAudience ClaimStrings `json:\"aud,omitempty\"`\n\n\t// the `exp` (Expiration Time) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4\n\tExpiresAt *NumericDate `json:\"exp,omitempty\"`\n\n\t// the `nbf` (Not Before) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.5\n\tNotBefore *NumericDate `json:\"nbf,omitempty\"`\n\n\t// the `iat` (Issued At) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.6\n\tIssuedAt *NumericDate `json:\"iat,omitempty\"`\n\n\t// the `jti` (JWT ID) claim. See https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.7\n\tID string `json:\"jti,omitempty\"`\n}\n\n// Valid validates time based claims \"exp, iat, nbf\".\n// There is no accounting for clock skew.\n// As well, if any of the above claims are not in the token, it will still\n// be considered a valid claim.\nfunc (c RegisteredClaims) Valid() error {\n\tvErr := new(ValidationError)\n\tnow := TimeFunc()\n\n\t// The claims below are optional, by default, so if they are set to the\n\t// default value in Go, let's not fail the verification for them.\n\tif !c.VerifyExpiresAt(now, false) {\n\t\tdelta := now.Sub(c.ExpiresAt.Time)\n\t\tvErr.Inner = fmt.Errorf(\"%s by %s\", ErrTokenExpired, delta)\n\t\tvErr.Errors |= ValidationErrorExpired\n\t}\n\n\tif !c.VerifyIssuedAt(now, false) {\n\t\tvErr.Inner = ErrTokenUsedBeforeIssued\n\t\tvErr.Errors |= ValidationErrorIssuedAt\n\t}\n\n\tif !c.VerifyNotBefore(now, false) {\n\t\tvErr.Inner = ErrTokenNotValidYet\n\t\tvErr.Errors |= ValidationErrorNotValidYet\n\t}\n\n\tif vErr.valid() {\n\t\treturn nil\n\t}\n\n\treturn vErr\n}\n\n// VerifyAudience compares the aud claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (c *RegisteredClaims) VerifyAudience(cmp string, req bool) bool {\n\treturn verifyAud(c.Audience, cmp, req)\n}\n\n// VerifyExpiresAt compares the exp claim against cmp (cmp < exp).\n// If req is false, it will return true, if exp is unset.\nfunc (c *RegisteredClaims) VerifyExpiresAt(cmp time.Time, req bool) bool {\n\tif c.ExpiresAt == nil {\n\t\treturn verifyExp(nil, cmp, req)\n\t}\n\n\treturn verifyExp(&c.ExpiresAt.Time, cmp, req)\n}\n\n// VerifyIssuedAt compares the iat claim against cmp (cmp >= iat).\n// If req is false, it will return true, if iat is unset.\nfunc (c *RegisteredClaims) VerifyIssuedAt(cmp time.Time, req bool) bool {\n\tif c.IssuedAt == nil {\n\t\treturn verifyIat(nil, cmp, req)\n\t}\n\n\treturn verifyIat(&c.IssuedAt.Time, cmp, req)\n}\n\n// VerifyNotBefore compares the nbf claim against cmp (cmp >= nbf).\n// If req is false, it will return true, if nbf is unset.\nfunc (c *RegisteredClaims) VerifyNotBefore(cmp time.Time, req bool) bool {\n\tif c.NotBefore == nil {\n\t\treturn verifyNbf(nil, cmp, req)\n\t}\n\n\treturn verifyNbf(&c.NotBefore.Time, cmp, req)\n}\n\n// VerifyIssuer compares the iss claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (c *RegisteredClaims) VerifyIssuer(cmp string, req bool) bool {\n\treturn verifyIss(c.Issuer, cmp, req)\n}\n\n// StandardClaims are a structured version of the JWT Claims Set, as referenced at\n// https://datatracker.ietf.org/doc/html/rfc7519#section-4. They do not follow the\n// specification exactly, since they were based on an earlier draft of the\n// specification and not updated. The main difference is that they only\n// support integer-based date fields and singular audiences. This might lead to\n// incompatibilities with other JWT implementations. The use of this is discouraged, instead\n// the newer RegisteredClaims struct should be used.\n//\n// Deprecated: Use RegisteredClaims instead for a forward-compatible way to access registered claims in a struct.\ntype StandardClaims struct {\n\tAudience string `json:\"aud,omitempty\"`\n\tExpiresAt int64 `json:\"exp,omitempty\"`\n\tId string `json:\"jti,omitempty\"`\n\tIssuedAt int64 `json:\"iat,omitempty\"`\n\tIssuer string `json:\"iss,omitempty\"`\n\tNotBefore int64 `json:\"nbf,omitempty\"`\n\tSubject string `json:\"sub,omitempty\"`\n}\n\n// Valid validates time based claims \"exp, iat, nbf\". There is no accounting for clock skew.\n// As well, if any of the above claims are not in the token, it will still\n// be considered a valid claim.\nfunc (c StandardClaims) Valid() error {\n\tvErr := new(ValidationError)\n\tnow := TimeFunc().Unix()\n\n\t// The claims below are optional, by default, so if they are set to the\n\t// default value in Go, let's not fail the verification for them.\n\tif !c.VerifyExpiresAt(now, false) {\n\t\tdelta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0))\n\t\tvErr.Inner = fmt.Errorf(\"%s by %s\", ErrTokenExpired, delta)\n\t\tvErr.Errors |= ValidationErrorExpired\n\t}\n\n\tif !c.VerifyIssuedAt(now, false) {\n\t\tvErr.Inner = ErrTokenUsedBeforeIssued\n\t\tvErr.Errors |= ValidationErrorIssuedAt\n\t}\n\n\tif !c.VerifyNotBefore(now, false) {\n\t\tvErr.Inner = ErrTokenNotValidYet\n\t\tvErr.Errors |= ValidationErrorNotValidYet\n\t}\n\n\tif vErr.valid() {\n\t\treturn nil\n\t}\n\n\treturn vErr\n}\n\n// VerifyAudience compares the aud claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (c *StandardClaims) VerifyAudience(cmp string, req bool) bool {\n\treturn verifyAud([]string{c.Audience}, cmp, req)\n}\n\n// VerifyExpiresAt compares the exp claim against cmp (cmp < exp).\n// If req is false, it will return true, if exp is unset.\nfunc (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool {\n\tif c.ExpiresAt == 0 {\n\t\treturn verifyExp(nil, time.Unix(cmp, 0), req)\n\t}\n\n\tt := time.Unix(c.ExpiresAt, 0)\n\treturn verifyExp(&t, time.Unix(cmp, 0), req)\n}\n\n// VerifyIssuedAt compares the iat claim against cmp (cmp >= iat).\n// If req is false, it will return true, if iat is unset.\nfunc (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool {\n\tif c.IssuedAt == 0 {\n\t\treturn verifyIat(nil, time.Unix(cmp, 0), req)\n\t}\n\n\tt := time.Unix(c.IssuedAt, 0)\n\treturn verifyIat(&t, time.Unix(cmp, 0), req)\n}\n\n// VerifyNotBefore compares the nbf claim against cmp (cmp >= nbf).\n// If req is false, it will return true, if nbf is unset.\nfunc (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool {\n\tif c.NotBefore == 0 {\n\t\treturn verifyNbf(nil, time.Unix(cmp, 0), req)\n\t}\n\n\tt := time.Unix(c.NotBefore, 0)\n\treturn verifyNbf(&t, time.Unix(cmp, 0), req)\n}\n\n// VerifyIssuer compares the iss claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool {\n\treturn verifyIss(c.Issuer, cmp, req)\n}\n\n// ----- helpers\n\nfunc verifyAud(aud []string, cmp string, required bool) bool {\n\tif len(aud) == 0 {\n\t\treturn !required\n\t}\n\t// use a var here to keep constant time compare when looping over a number of claims\n\tresult := false\n\n\tvar stringClaims string\n\tfor _, a := range aud {\n\t\tif subtle.ConstantTimeCompare([]byte(a), []byte(cmp)) != 0 {\n\t\t\tresult = true\n\t\t}\n\t\tstringClaims = stringClaims + a\n\t}\n\n\t// case where \"\" is sent in one or many aud claims\n\tif len(stringClaims) == 0 {\n\t\treturn !required\n\t}\n\n\treturn result\n}\n\nfunc verifyExp(exp *time.Time, now time.Time, required bool) bool {\n\tif exp == nil {\n\t\treturn !required\n\t}\n\treturn now.Before(*exp)\n}\n\nfunc verifyIat(iat *time.Time, now time.Time, required bool) bool {\n\tif iat == nil {\n\t\treturn !required\n\t}\n\treturn now.After(*iat) || now.Equal(*iat)\n}\n\nfunc verifyNbf(nbf *time.Time, now time.Time, required bool) bool {\n\tif nbf == nil {\n\t\treturn !required\n\t}\n\treturn now.After(*nbf) || now.Equal(*nbf)\n}\n\nfunc verifyIss(iss string, cmp string, required bool) bool {\n\tif iss == \"\" {\n\t\treturn !required\n\t}\n\treturn subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/doc.go",
"content": "// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html\n//\n// See README.md for more info.\npackage jwt\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/ecdsa.go",
"content": "package jwt\n\nimport (\n\t\"crypto\"\n\t\"crypto/ecdsa\"\n\t\"crypto/rand\"\n\t\"errors\"\n\t\"math/big\"\n)\n\nvar (\n\t// Sadly this is missing from crypto/ecdsa compared to crypto/rsa\n\tErrECDSAVerification = errors.New(\"crypto/ecdsa: verification error\")\n)\n\n// SigningMethodECDSA implements the ECDSA family of signing methods.\n// Expects *ecdsa.PrivateKey for signing and *ecdsa.PublicKey for verification\ntype SigningMethodECDSA struct {\n\tName string\n\tHash crypto.Hash\n\tKeySize int\n\tCurveBits int\n}\n\n// Specific instances for EC256 and company\nvar (\n\tSigningMethodES256 *SigningMethodECDSA\n\tSigningMethodES384 *SigningMethodECDSA\n\tSigningMethodES512 *SigningMethodECDSA\n)\n\nfunc init() {\n\t// ES256\n\tSigningMethodES256 = &SigningMethodECDSA{\"ES256\", crypto.SHA256, 32, 256}\n\tRegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod {\n\t\treturn SigningMethodES256\n\t})\n\n\t// ES384\n\tSigningMethodES384 = &SigningMethodECDSA{\"ES384\", crypto.SHA384, 48, 384}\n\tRegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod {\n\t\treturn SigningMethodES384\n\t})\n\n\t// ES512\n\tSigningMethodES512 = &SigningMethodECDSA{\"ES512\", crypto.SHA512, 66, 521}\n\tRegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod {\n\t\treturn SigningMethodES512\n\t})\n}\n\nfunc (m *SigningMethodECDSA) Alg() string {\n\treturn m.Name\n}\n\n// Verify implements token verification for the SigningMethod.\n// For this verify method, key must be an ecdsa.PublicKey struct\nfunc (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error {\n\tvar err error\n\n\t// Decode the signature\n\tvar sig []byte\n\tif sig, err = DecodeSegment(signature); err != nil {\n\t\treturn err\n\t}\n\n\t// Get the key\n\tvar ecdsaKey *ecdsa.PublicKey\n\tswitch k := key.(type) {\n\tcase *ecdsa.PublicKey:\n\t\tecdsaKey = k\n\tdefault:\n\t\treturn ErrInvalidKeyType\n\t}\n\n\tif len(sig) != 2*m.KeySize {\n\t\treturn ErrECDSAVerification\n\t}\n\n\tr := big.NewInt(0).SetBytes(sig[:m.KeySize])\n\ts := big.NewInt(0).SetBytes(sig[m.KeySize:])\n\n\t// Create hasher\n\tif !m.Hash.Available() {\n\t\treturn ErrHashUnavailable\n\t}\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\t// Verify the signature\n\tif verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus {\n\t\treturn nil\n\t}\n\n\treturn ErrECDSAVerification\n}\n\n// Sign implements token signing for the SigningMethod.\n// For this signing method, key must be an ecdsa.PrivateKey struct\nfunc (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {\n\t// Get the key\n\tvar ecdsaKey *ecdsa.PrivateKey\n\tswitch k := key.(type) {\n\tcase *ecdsa.PrivateKey:\n\t\tecdsaKey = k\n\tdefault:\n\t\treturn \"\", ErrInvalidKeyType\n\t}\n\n\t// Create the hasher\n\tif !m.Hash.Available() {\n\t\treturn \"\", ErrHashUnavailable\n\t}\n\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\t// Sign the string and return r, s\n\tif r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {\n\t\tcurveBits := ecdsaKey.Curve.Params().BitSize\n\n\t\tif m.CurveBits != curveBits {\n\t\t\treturn \"\", ErrInvalidKey\n\t\t}\n\n\t\tkeyBytes := curveBits / 8\n\t\tif curveBits%8 > 0 {\n\t\t\tkeyBytes += 1\n\t\t}\n\n\t\t// We serialize the outputs (r and s) into big-endian byte arrays\n\t\t// padded with zeros on the left to make sure the sizes work out.\n\t\t// Output must be 2*keyBytes long.\n\t\tout := make([]byte, 2*keyBytes)\n\t\tr.FillBytes(out[0:keyBytes]) // r is assigned to the first half of output.\n\t\ts.FillBytes(out[keyBytes:]) // s is assigned to the second half of output.\n\n\t\treturn EncodeSegment(out), nil\n\t} else {\n\t\treturn \"\", err\n\t}\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/ecdsa_utils.go",
"content": "package jwt\n\nimport (\n\t\"crypto/ecdsa\"\n\t\"crypto/x509\"\n\t\"encoding/pem\"\n\t\"errors\"\n)\n\nvar (\n\tErrNotECPublicKey = errors.New(\"key is not a valid ECDSA public key\")\n\tErrNotECPrivateKey = errors.New(\"key is not a valid ECDSA private key\")\n)\n\n// ParseECPrivateKeyFromPEM parses a PEM encoded Elliptic Curve Private Key Structure\nfunc ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\t// Parse the key\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil {\n\t\tif parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tvar pkey *ecdsa.PrivateKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok {\n\t\treturn nil, ErrNotECPrivateKey\n\t}\n\n\treturn pkey, nil\n}\n\n// ParseECPublicKeyFromPEM parses a PEM encoded PKCS1 or PKCS8 public key\nfunc ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\t// Parse the key\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {\n\t\tif cert, err := x509.ParseCertificate(block.Bytes); err == nil {\n\t\t\tparsedKey = cert.PublicKey\n\t\t} else {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tvar pkey *ecdsa.PublicKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok {\n\t\treturn nil, ErrNotECPublicKey\n\t}\n\n\treturn pkey, nil\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/ed25519.go",
"content": "package jwt\n\nimport (\n\t\"errors\"\n\n\t\"crypto\"\n\t\"crypto/ed25519\"\n\t\"crypto/rand\"\n)\n\nvar (\n\tErrEd25519Verification = errors.New(\"ed25519: verification error\")\n)\n\n// SigningMethodEd25519 implements the EdDSA family.\n// Expects ed25519.PrivateKey for signing and ed25519.PublicKey for verification\ntype SigningMethodEd25519 struct{}\n\n// Specific instance for EdDSA\nvar (\n\tSigningMethodEdDSA *SigningMethodEd25519\n)\n\nfunc init() {\n\tSigningMethodEdDSA = &SigningMethodEd25519{}\n\tRegisterSigningMethod(SigningMethodEdDSA.Alg(), func() SigningMethod {\n\t\treturn SigningMethodEdDSA\n\t})\n}\n\nfunc (m *SigningMethodEd25519) Alg() string {\n\treturn \"EdDSA\"\n}\n\n// Verify implements token verification for the SigningMethod.\n// For this verify method, key must be an ed25519.PublicKey\nfunc (m *SigningMethodEd25519) Verify(signingString, signature string, key interface{}) error {\n\tvar err error\n\tvar ed25519Key ed25519.PublicKey\n\tvar ok bool\n\n\tif ed25519Key, ok = key.(ed25519.PublicKey); !ok {\n\t\treturn ErrInvalidKeyType\n\t}\n\n\tif len(ed25519Key) != ed25519.PublicKeySize {\n\t\treturn ErrInvalidKey\n\t}\n\n\t// Decode the signature\n\tvar sig []byte\n\tif sig, err = DecodeSegment(signature); err != nil {\n\t\treturn err\n\t}\n\n\t// Verify the signature\n\tif !ed25519.Verify(ed25519Key, []byte(signingString), sig) {\n\t\treturn ErrEd25519Verification\n\t}\n\n\treturn nil\n}\n\n// Sign implements token signing for the SigningMethod.\n// For this signing method, key must be an ed25519.PrivateKey\nfunc (m *SigningMethodEd25519) Sign(signingString string, key interface{}) (string, error) {\n\tvar ed25519Key crypto.Signer\n\tvar ok bool\n\n\tif ed25519Key, ok = key.(crypto.Signer); !ok {\n\t\treturn \"\", ErrInvalidKeyType\n\t}\n\n\tif _, ok := ed25519Key.Public().(ed25519.PublicKey); !ok {\n\t\treturn \"\", ErrInvalidKey\n\t}\n\n\t// Sign the string and return the encoded result\n\t// ed25519 performs a two-pass hash as part of its algorithm. Therefore, we need to pass a non-prehashed message into the Sign function, as indicated by crypto.Hash(0)\n\tsig, err := ed25519Key.Sign(rand.Reader, []byte(signingString), crypto.Hash(0))\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\treturn EncodeSegment(sig), nil\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/ed25519_utils.go",
"content": "package jwt\n\nimport (\n\t\"crypto\"\n\t\"crypto/ed25519\"\n\t\"crypto/x509\"\n\t\"encoding/pem\"\n\t\"errors\"\n)\n\nvar (\n\tErrNotEdPrivateKey = errors.New(\"key is not a valid Ed25519 private key\")\n\tErrNotEdPublicKey = errors.New(\"key is not a valid Ed25519 public key\")\n)\n\n// ParseEdPrivateKeyFromPEM parses a PEM-encoded Edwards curve private key\nfunc ParseEdPrivateKeyFromPEM(key []byte) (crypto.PrivateKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\t// Parse the key\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar pkey ed25519.PrivateKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(ed25519.PrivateKey); !ok {\n\t\treturn nil, ErrNotEdPrivateKey\n\t}\n\n\treturn pkey, nil\n}\n\n// ParseEdPublicKeyFromPEM parses a PEM-encoded Edwards curve public key\nfunc ParseEdPublicKeyFromPEM(key []byte) (crypto.PublicKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\t// Parse the key\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar pkey ed25519.PublicKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(ed25519.PublicKey); !ok {\n\t\treturn nil, ErrNotEdPublicKey\n\t}\n\n\treturn pkey, nil\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/errors.go",
"content": "package jwt\n\nimport (\n\t\"errors\"\n)\n\n// Error constants\nvar (\n\tErrInvalidKey = errors.New(\"key is invalid\")\n\tErrInvalidKeyType = errors.New(\"key is of invalid type\")\n\tErrHashUnavailable = errors.New(\"the requested hash function is unavailable\")\n\n\tErrTokenMalformed = errors.New(\"token is malformed\")\n\tErrTokenUnverifiable = errors.New(\"token is unverifiable\")\n\tErrTokenSignatureInvalid = errors.New(\"token signature is invalid\")\n\n\tErrTokenInvalidAudience = errors.New(\"token has invalid audience\")\n\tErrTokenExpired = errors.New(\"token is expired\")\n\tErrTokenUsedBeforeIssued = errors.New(\"token used before issued\")\n\tErrTokenInvalidIssuer = errors.New(\"token has invalid issuer\")\n\tErrTokenNotValidYet = errors.New(\"token is not valid yet\")\n\tErrTokenInvalidId = errors.New(\"token has invalid id\")\n\tErrTokenInvalidClaims = errors.New(\"token has invalid claims\")\n)\n\n// The errors that might occur when parsing and validating a token\nconst (\n\tValidationErrorMalformed uint32 = 1 << iota // Token is malformed\n\tValidationErrorUnverifiable // Token could not be verified because of signing problems\n\tValidationErrorSignatureInvalid // Signature validation failed\n\n\t// Standard Claim validation errors\n\tValidationErrorAudience // AUD validation failed\n\tValidationErrorExpired // EXP validation failed\n\tValidationErrorIssuedAt // IAT validation failed\n\tValidationErrorIssuer // ISS validation failed\n\tValidationErrorNotValidYet // NBF validation failed\n\tValidationErrorId // JTI validation failed\n\tValidationErrorClaimsInvalid // Generic claims validation error\n)\n\n// NewValidationError is a helper for constructing a ValidationError with a string error message\nfunc NewValidationError(errorText string, errorFlags uint32) *ValidationError {\n\treturn &ValidationError{\n\t\ttext: errorText,\n\t\tErrors: errorFlags,\n\t}\n}\n\n// ValidationError represents an error from Parse if token is not valid\ntype ValidationError struct {\n\tInner error // stores the error returned by external dependencies, i.e.: KeyFunc\n\tErrors uint32 // bitfield. see ValidationError... constants\n\ttext string // errors that do not have a valid error just have text\n}\n\n// Error is the implementation of the err interface.\nfunc (e ValidationError) Error() string {\n\tif e.Inner != nil {\n\t\treturn e.Inner.Error()\n\t} else if e.text != \"\" {\n\t\treturn e.text\n\t} else {\n\t\treturn \"token is invalid\"\n\t}\n}\n\n// Unwrap gives errors.Is and errors.As access to the inner error.\nfunc (e *ValidationError) Unwrap() error {\n\treturn e.Inner\n}\n\n// No errors\nfunc (e *ValidationError) valid() bool {\n\treturn e.Errors == 0\n}\n\n// Is checks if this ValidationError is of the supplied error. We are first checking for the exact error message\n// by comparing the inner error message. If that fails, we compare using the error flags. This way we can use\n// custom error messages (mainly for backwards compatability) and still leverage errors.Is using the global error variables.\nfunc (e *ValidationError) Is(err error) bool {\n\t// Check, if our inner error is a direct match\n\tif errors.Is(errors.Unwrap(e), err) {\n\t\treturn true\n\t}\n\n\t// Otherwise, we need to match using our error flags\n\tswitch err {\n\tcase ErrTokenMalformed:\n\t\treturn e.Errors&ValidationErrorMalformed != 0\n\tcase ErrTokenUnverifiable:\n\t\treturn e.Errors&ValidationErrorUnverifiable != 0\n\tcase ErrTokenSignatureInvalid:\n\t\treturn e.Errors&ValidationErrorSignatureInvalid != 0\n\tcase ErrTokenInvalidAudience:\n\t\treturn e.Errors&ValidationErrorAudience != 0\n\tcase ErrTokenExpired:\n\t\treturn e.Errors&ValidationErrorExpired != 0\n\tcase ErrTokenUsedBeforeIssued:\n\t\treturn e.Errors&ValidationErrorIssuedAt != 0\n\tcase ErrTokenInvalidIssuer:\n\t\treturn e.Errors&ValidationErrorIssuer != 0\n\tcase ErrTokenNotValidYet:\n\t\treturn e.Errors&ValidationErrorNotValidYet != 0\n\tcase ErrTokenInvalidId:\n\t\treturn e.Errors&ValidationErrorId != 0\n\tcase ErrTokenInvalidClaims:\n\t\treturn e.Errors&ValidationErrorClaimsInvalid != 0\n\t}\n\n\treturn false\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/hmac.go",
"content": "package jwt\n\nimport (\n\t\"crypto\"\n\t\"crypto/hmac\"\n\t\"errors\"\n)\n\n// SigningMethodHMAC implements the HMAC-SHA family of signing methods.\n// Expects key type of []byte for both signing and validation\ntype SigningMethodHMAC struct {\n\tName string\n\tHash crypto.Hash\n}\n\n// Specific instances for HS256 and company\nvar (\n\tSigningMethodHS256 *SigningMethodHMAC\n\tSigningMethodHS384 *SigningMethodHMAC\n\tSigningMethodHS512 *SigningMethodHMAC\n\tErrSignatureInvalid = errors.New(\"signature is invalid\")\n)\n\nfunc init() {\n\t// HS256\n\tSigningMethodHS256 = &SigningMethodHMAC{\"HS256\", crypto.SHA256}\n\tRegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod {\n\t\treturn SigningMethodHS256\n\t})\n\n\t// HS384\n\tSigningMethodHS384 = &SigningMethodHMAC{\"HS384\", crypto.SHA384}\n\tRegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod {\n\t\treturn SigningMethodHS384\n\t})\n\n\t// HS512\n\tSigningMethodHS512 = &SigningMethodHMAC{\"HS512\", crypto.SHA512}\n\tRegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod {\n\t\treturn SigningMethodHS512\n\t})\n}\n\nfunc (m *SigningMethodHMAC) Alg() string {\n\treturn m.Name\n}\n\n// Verify implements token verification for the SigningMethod. Returns nil if the signature is valid.\nfunc (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error {\n\t// Verify the key is the right type\n\tkeyBytes, ok := key.([]byte)\n\tif !ok {\n\t\treturn ErrInvalidKeyType\n\t}\n\n\t// Decode signature, for comparison\n\tsig, err := DecodeSegment(signature)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// Can we use the specified hashing method?\n\tif !m.Hash.Available() {\n\t\treturn ErrHashUnavailable\n\t}\n\n\t// This signing method is symmetric, so we validate the signature\n\t// by reproducing the signature from the signing string and key, then\n\t// comparing that against the provided signature.\n\thasher := hmac.New(m.Hash.New, keyBytes)\n\thasher.Write([]byte(signingString))\n\tif !hmac.Equal(sig, hasher.Sum(nil)) {\n\t\treturn ErrSignatureInvalid\n\t}\n\n\t// No validation errors. Signature is good.\n\treturn nil\n}\n\n// Sign implements token signing for the SigningMethod.\n// Key must be []byte\nfunc (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) {\n\tif keyBytes, ok := key.([]byte); ok {\n\t\tif !m.Hash.Available() {\n\t\t\treturn \"\", ErrHashUnavailable\n\t\t}\n\n\t\thasher := hmac.New(m.Hash.New, keyBytes)\n\t\thasher.Write([]byte(signingString))\n\n\t\treturn EncodeSegment(hasher.Sum(nil)), nil\n\t}\n\n\treturn \"\", ErrInvalidKeyType\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/map_claims.go",
"content": "package jwt\n\nimport (\n\t\"encoding/json\"\n\t\"errors\"\n\t\"time\"\n\t// \"fmt\"\n)\n\n// MapClaims is a claims type that uses the map[string]interface{} for JSON decoding.\n// This is the default claims type if you don't supply one\ntype MapClaims map[string]interface{}\n\n// VerifyAudience Compares the aud claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (m MapClaims) VerifyAudience(cmp string, req bool) bool {\n\tvar aud []string\n\tswitch v := m[\"aud\"].(type) {\n\tcase string:\n\t\taud = append(aud, v)\n\tcase []string:\n\t\taud = v\n\tcase []interface{}:\n\t\tfor _, a := range v {\n\t\t\tvs, ok := a.(string)\n\t\t\tif !ok {\n\t\t\t\treturn false\n\t\t\t}\n\t\t\taud = append(aud, vs)\n\t\t}\n\t}\n\treturn verifyAud(aud, cmp, req)\n}\n\n// VerifyExpiresAt compares the exp claim against cmp (cmp <= exp).\n// If req is false, it will return true, if exp is unset.\nfunc (m MapClaims) VerifyExpiresAt(cmp int64, req bool) bool {\n\tcmpTime := time.Unix(cmp, 0)\n\n\tv, ok := m[\"exp\"]\n\tif !ok {\n\t\treturn !req\n\t}\n\n\tswitch exp := v.(type) {\n\tcase float64:\n\t\tif exp == 0 {\n\t\t\treturn verifyExp(nil, cmpTime, req)\n\t\t}\n\n\t\treturn verifyExp(&newNumericDateFromSeconds(exp).Time, cmpTime, req)\n\tcase json.Number:\n\t\tv, _ := exp.Float64()\n\n\t\treturn verifyExp(&newNumericDateFromSeconds(v).Time, cmpTime, req)\n\t}\n\n\treturn false\n}\n\n// VerifyIssuedAt compares the exp claim against cmp (cmp >= iat).\n// If req is false, it will return true, if iat is unset.\nfunc (m MapClaims) VerifyIssuedAt(cmp int64, req bool) bool {\n\tcmpTime := time.Unix(cmp, 0)\n\n\tv, ok := m[\"iat\"]\n\tif !ok {\n\t\treturn !req\n\t}\n\n\tswitch iat := v.(type) {\n\tcase float64:\n\t\tif iat == 0 {\n\t\t\treturn verifyIat(nil, cmpTime, req)\n\t\t}\n\n\t\treturn verifyIat(&newNumericDateFromSeconds(iat).Time, cmpTime, req)\n\tcase json.Number:\n\t\tv, _ := iat.Float64()\n\n\t\treturn verifyIat(&newNumericDateFromSeconds(v).Time, cmpTime, req)\n\t}\n\n\treturn false\n}\n\n// VerifyNotBefore compares the nbf claim against cmp (cmp >= nbf).\n// If req is false, it will return true, if nbf is unset.\nfunc (m MapClaims) VerifyNotBefore(cmp int64, req bool) bool {\n\tcmpTime := time.Unix(cmp, 0)\n\n\tv, ok := m[\"nbf\"]\n\tif !ok {\n\t\treturn !req\n\t}\n\n\tswitch nbf := v.(type) {\n\tcase float64:\n\t\tif nbf == 0 {\n\t\t\treturn verifyNbf(nil, cmpTime, req)\n\t\t}\n\n\t\treturn verifyNbf(&newNumericDateFromSeconds(nbf).Time, cmpTime, req)\n\tcase json.Number:\n\t\tv, _ := nbf.Float64()\n\n\t\treturn verifyNbf(&newNumericDateFromSeconds(v).Time, cmpTime, req)\n\t}\n\n\treturn false\n}\n\n// VerifyIssuer compares the iss claim against cmp.\n// If required is false, this method will return true if the value matches or is unset\nfunc (m MapClaims) VerifyIssuer(cmp string, req bool) bool {\n\tiss, _ := m[\"iss\"].(string)\n\treturn verifyIss(iss, cmp, req)\n}\n\n// Valid validates time based claims \"exp, iat, nbf\".\n// There is no accounting for clock skew.\n// As well, if any of the above claims are not in the token, it will still\n// be considered a valid claim.\nfunc (m MapClaims) Valid() error {\n\tvErr := new(ValidationError)\n\tnow := TimeFunc().Unix()\n\n\tif !m.VerifyExpiresAt(now, false) {\n\t\t// TODO(oxisto): this should be replaced with ErrTokenExpired\n\t\tvErr.Inner = errors.New(\"Token is expired\")\n\t\tvErr.Errors |= ValidationErrorExpired\n\t}\n\n\tif !m.VerifyIssuedAt(now, false) {\n\t\t// TODO(oxisto): this should be replaced with ErrTokenUsedBeforeIssued\n\t\tvErr.Inner = errors.New(\"Token used before issued\")\n\t\tvErr.Errors |= ValidationErrorIssuedAt\n\t}\n\n\tif !m.VerifyNotBefore(now, false) {\n\t\t// TODO(oxisto): this should be replaced with ErrTokenNotValidYet\n\t\tvErr.Inner = errors.New(\"Token is not valid yet\")\n\t\tvErr.Errors |= ValidationErrorNotValidYet\n\t}\n\n\tif vErr.valid() {\n\t\treturn nil\n\t}\n\n\treturn vErr\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/none.go",
"content": "package jwt\n\n// SigningMethodNone implements the none signing method. This is required by the spec\n// but you probably should never use it.\nvar SigningMethodNone *signingMethodNone\n\nconst UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = \"none signing method allowed\"\n\nvar NoneSignatureTypeDisallowedError error\n\ntype signingMethodNone struct{}\ntype unsafeNoneMagicConstant string\n\nfunc init() {\n\tSigningMethodNone = &signingMethodNone{}\n\tNoneSignatureTypeDisallowedError = NewValidationError(\"'none' signature type is not allowed\", ValidationErrorSignatureInvalid)\n\n\tRegisterSigningMethod(SigningMethodNone.Alg(), func() SigningMethod {\n\t\treturn SigningMethodNone\n\t})\n}\n\nfunc (m *signingMethodNone) Alg() string {\n\treturn \"none\"\n}\n\n// Only allow 'none' alg type if UnsafeAllowNoneSignatureType is specified as the key\nfunc (m *signingMethodNone) Verify(signingString, signature string, key interface{}) (err error) {\n\t// Key must be UnsafeAllowNoneSignatureType to prevent accidentally\n\t// accepting 'none' signing method\n\tif _, ok := key.(unsafeNoneMagicConstant); !ok {\n\t\treturn NoneSignatureTypeDisallowedError\n\t}\n\t// If signing method is none, signature must be an empty string\n\tif signature != \"\" {\n\t\treturn NewValidationError(\n\t\t\t\"'none' signing method with non-empty signature\",\n\t\t\tValidationErrorSignatureInvalid,\n\t\t)\n\t}\n\n\t// Accept 'none' signing method.\n\treturn nil\n}\n\n// Only allow 'none' signing if UnsafeAllowNoneSignatureType is specified as the key\nfunc (m *signingMethodNone) Sign(signingString string, key interface{}) (string, error) {\n\tif _, ok := key.(unsafeNoneMagicConstant); ok {\n\t\treturn \"\", nil\n\t}\n\treturn \"\", NoneSignatureTypeDisallowedError\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/parser.go",
"content": "package jwt\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"strings\"\n)\n\nconst tokenDelimiter = \".\"\n\ntype Parser struct {\n\t// If populated, only these methods will be considered valid.\n\t//\n\t// Deprecated: In future releases, this field will not be exported anymore and should be set with an option to NewParser instead.\n\tValidMethods []string\n\n\t// Use JSON Number format in JSON decoder.\n\t//\n\t// Deprecated: In future releases, this field will not be exported anymore and should be set with an option to NewParser instead.\n\tUseJSONNumber bool\n\n\t// Skip claims validation during token parsing.\n\t//\n\t// Deprecated: In future releases, this field will not be exported anymore and should be set with an option to NewParser instead.\n\tSkipClaimsValidation bool\n}\n\n// NewParser creates a new Parser with the specified options\nfunc NewParser(options ...ParserOption) *Parser {\n\tp := &Parser{}\n\n\t// loop through our parsing options and apply them\n\tfor _, option := range options {\n\t\toption(p)\n\t}\n\n\treturn p\n}\n\n// Parse parses, validates, verifies the signature and returns the parsed token. keyFunc will\n// receive the parsed token and should return the key for validating.\nfunc (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {\n\treturn p.ParseWithClaims(tokenString, MapClaims{}, keyFunc)\n}\n\n// ParseWithClaims parses, validates, and verifies like Parse, but supplies a default object\n// implementing the Claims interface. This provides default values which can be overridden and\n// allows a caller to use their own type, rather than the default MapClaims implementation of\n// Claims.\n//\n// Note: If you provide a custom claim implementation that embeds one of the standard claims (such\n// as RegisteredClaims), make sure that a) you either embed a non-pointer version of the claims or\n// b) if you are using a pointer, allocate the proper memory for it before passing in the overall\n// claims, otherwise you might run into a panic.\nfunc (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {\n\ttoken, parts, err := p.ParseUnverified(tokenString, claims)\n\tif err != nil {\n\t\treturn token, err\n\t}\n\n\t// Verify signing method is in the required set\n\tif p.ValidMethods != nil {\n\t\tvar signingMethodValid = false\n\t\tvar alg = token.Method.Alg()\n\t\tfor _, m := range p.ValidMethods {\n\t\t\tif m == alg {\n\t\t\t\tsigningMethodValid = true\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\tif !signingMethodValid {\n\t\t\t// signing method is not in the listed set\n\t\t\treturn token, NewValidationError(fmt.Sprintf(\"signing method %v is invalid\", alg), ValidationErrorSignatureInvalid)\n\t\t}\n\t}\n\n\t// Lookup key\n\tvar key interface{}\n\tif keyFunc == nil {\n\t\t// keyFunc was not provided. short circuiting validation\n\t\treturn token, NewValidationError(\"no Keyfunc was provided.\", ValidationErrorUnverifiable)\n\t}\n\tif key, err = keyFunc(token); err != nil {\n\t\t// keyFunc returned an error\n\t\tif ve, ok := err.(*ValidationError); ok {\n\t\t\treturn token, ve\n\t\t}\n\t\treturn token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable}\n\t}\n\n\t// Perform validation\n\ttoken.Signature = parts[2]\n\tif err := token.Method.Verify(strings.Join(parts[0:2], \".\"), token.Signature, key); err != nil {\n\t\treturn token, &ValidationError{Inner: err, Errors: ValidationErrorSignatureInvalid}\n\t}\n\n\tvErr := &ValidationError{}\n\n\t// Validate Claims\n\tif !p.SkipClaimsValidation {\n\t\tif err := token.Claims.Valid(); err != nil {\n\t\t\t// If the Claims Valid returned an error, check if it is a validation error,\n\t\t\t// If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set\n\t\t\tif e, ok := err.(*ValidationError); !ok {\n\t\t\t\tvErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid}\n\t\t\t} else {\n\t\t\t\tvErr = e\n\t\t\t}\n\t\t\treturn token, vErr\n\t\t}\n\t}\n\n\t// No errors so far, token is valid.\n\ttoken.Valid = true\n\n\treturn token, nil\n}\n\n// ParseUnverified parses the token but doesn't validate the signature.\n//\n// WARNING: Don't use this method unless you know what you're doing.\n//\n// It's only ever useful in cases where you know the signature is valid (because it has\n// been checked previously in the stack) and you want to extract values from it.\nfunc (p *Parser) ParseUnverified(tokenString string, claims Claims) (token *Token, parts []string, err error) {\n\tvar ok bool\n\tparts, ok = splitToken(tokenString)\n\tif !ok {\n\t\treturn nil, nil, NewValidationError(\"token contains an invalid number of segments\", ValidationErrorMalformed)\n\t}\n\n\ttoken = &Token{Raw: tokenString}\n\n\t// parse Header\n\tvar headerBytes []byte\n\tif headerBytes, err = DecodeSegment(parts[0]); err != nil {\n\t\tif strings.HasPrefix(strings.ToLower(tokenString), \"bearer \") {\n\t\t\treturn token, parts, NewValidationError(\"tokenstring should not contain 'bearer '\", ValidationErrorMalformed)\n\t\t}\n\t\treturn token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}\n\t}\n\tif err = json.Unmarshal(headerBytes, &token.Header); err != nil {\n\t\treturn token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}\n\t}\n\n\t// parse Claims\n\tvar claimBytes []byte\n\ttoken.Claims = claims\n\n\tif claimBytes, err = DecodeSegment(parts[1]); err != nil {\n\t\treturn token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}\n\t}\n\tdec := json.NewDecoder(bytes.NewBuffer(claimBytes))\n\tif p.UseJSONNumber {\n\t\tdec.UseNumber()\n\t}\n\t// JSON Decode. Special case for map type to avoid weird pointer behavior\n\tif c, ok := token.Claims.(MapClaims); ok {\n\t\terr = dec.Decode(&c)\n\t} else {\n\t\terr = dec.Decode(&claims)\n\t}\n\t// Handle decode error\n\tif err != nil {\n\t\treturn token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}\n\t}\n\n\t// Lookup signature method\n\tif method, ok := token.Header[\"alg\"].(string); ok {\n\t\tif token.Method = GetSigningMethod(method); token.Method == nil {\n\t\t\treturn token, parts, NewValidationError(\"signing method (alg) is unavailable.\", ValidationErrorUnverifiable)\n\t\t}\n\t} else {\n\t\treturn token, parts, NewValidationError(\"signing method (alg) is unspecified.\", ValidationErrorUnverifiable)\n\t}\n\n\treturn token, parts, nil\n}\n\n// splitToken splits a token string into three parts: header, claims, and signature. It will only\n// return true if the token contains exactly two delimiters and three parts. In all other cases, it\n// will return nil parts and false.\nfunc splitToken(token string) ([]string, bool) {\n\tparts := make([]string, 3)\n\theader, remain, ok := strings.Cut(token, tokenDelimiter)\n\tif !ok {\n\t\treturn nil, false\n\t}\n\tparts[0] = header\n\tclaims, remain, ok := strings.Cut(remain, tokenDelimiter)\n\tif !ok {\n\t\treturn nil, false\n\t}\n\tparts[1] = claims\n\t// One more cut to ensure the signature is the last part of the token and there are no more\n\t// delimiters. This avoids an issue where malicious input could contain additional delimiters\n\t// causing unecessary overhead parsing tokens.\n\tsignature, _, unexpected := strings.Cut(remain, tokenDelimiter)\n\tif unexpected {\n\t\treturn nil, false\n\t}\n\tparts[2] = signature\n\n\treturn parts, true\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/parser_option.go",
"content": "package jwt\n\n// ParserOption is used to implement functional-style options that modify the behavior of the parser. To add\n// new options, just create a function (ideally beginning with With or Without) that returns an anonymous function that\n// takes a *Parser type as input and manipulates its configuration accordingly.\ntype ParserOption func(*Parser)\n\n// WithValidMethods is an option to supply algorithm methods that the parser will check. Only those methods will be considered valid.\n// It is heavily encouraged to use this option in order to prevent attacks such as https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/.\nfunc WithValidMethods(methods []string) ParserOption {\n\treturn func(p *Parser) {\n\t\tp.ValidMethods = methods\n\t}\n}\n\n// WithJSONNumber is an option to configure the underlying JSON parser with UseNumber\nfunc WithJSONNumber() ParserOption {\n\treturn func(p *Parser) {\n\t\tp.UseJSONNumber = true\n\t}\n}\n\n// WithoutClaimsValidation is an option to disable claims validation. This option should only be used if you exactly know\n// what you are doing.\nfunc WithoutClaimsValidation() ParserOption {\n\treturn func(p *Parser) {\n\t\tp.SkipClaimsValidation = true\n\t}\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/rsa.go",
"content": "package jwt\n\nimport (\n\t\"crypto\"\n\t\"crypto/rand\"\n\t\"crypto/rsa\"\n)\n\n// SigningMethodRSA implements the RSA family of signing methods.\n// Expects *rsa.PrivateKey for signing and *rsa.PublicKey for validation\ntype SigningMethodRSA struct {\n\tName string\n\tHash crypto.Hash\n}\n\n// Specific instances for RS256 and company\nvar (\n\tSigningMethodRS256 *SigningMethodRSA\n\tSigningMethodRS384 *SigningMethodRSA\n\tSigningMethodRS512 *SigningMethodRSA\n)\n\nfunc init() {\n\t// RS256\n\tSigningMethodRS256 = &SigningMethodRSA{\"RS256\", crypto.SHA256}\n\tRegisterSigningMethod(SigningMethodRS256.Alg(), func() SigningMethod {\n\t\treturn SigningMethodRS256\n\t})\n\n\t// RS384\n\tSigningMethodRS384 = &SigningMethodRSA{\"RS384\", crypto.SHA384}\n\tRegisterSigningMethod(SigningMethodRS384.Alg(), func() SigningMethod {\n\t\treturn SigningMethodRS384\n\t})\n\n\t// RS512\n\tSigningMethodRS512 = &SigningMethodRSA{\"RS512\", crypto.SHA512}\n\tRegisterSigningMethod(SigningMethodRS512.Alg(), func() SigningMethod {\n\t\treturn SigningMethodRS512\n\t})\n}\n\nfunc (m *SigningMethodRSA) Alg() string {\n\treturn m.Name\n}\n\n// Verify implements token verification for the SigningMethod\n// For this signing method, must be an *rsa.PublicKey structure.\nfunc (m *SigningMethodRSA) Verify(signingString, signature string, key interface{}) error {\n\tvar err error\n\n\t// Decode the signature\n\tvar sig []byte\n\tif sig, err = DecodeSegment(signature); err != nil {\n\t\treturn err\n\t}\n\n\tvar rsaKey *rsa.PublicKey\n\tvar ok bool\n\n\tif rsaKey, ok = key.(*rsa.PublicKey); !ok {\n\t\treturn ErrInvalidKeyType\n\t}\n\n\t// Create hasher\n\tif !m.Hash.Available() {\n\t\treturn ErrHashUnavailable\n\t}\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\t// Verify the signature\n\treturn rsa.VerifyPKCS1v15(rsaKey, m.Hash, hasher.Sum(nil), sig)\n}\n\n// Sign implements token signing for the SigningMethod\n// For this signing method, must be an *rsa.PrivateKey structure.\nfunc (m *SigningMethodRSA) Sign(signingString string, key interface{}) (string, error) {\n\tvar rsaKey *rsa.PrivateKey\n\tvar ok bool\n\n\t// Validate type of key\n\tif rsaKey, ok = key.(*rsa.PrivateKey); !ok {\n\t\treturn \"\", ErrInvalidKey\n\t}\n\n\t// Create the hasher\n\tif !m.Hash.Available() {\n\t\treturn \"\", ErrHashUnavailable\n\t}\n\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\t// Sign the string and return the encoded bytes\n\tif sigBytes, err := rsa.SignPKCS1v15(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil)); err == nil {\n\t\treturn EncodeSegment(sigBytes), nil\n\t} else {\n\t\treturn \"\", err\n\t}\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/rsa_pss.go",
"content": "//go:build go1.4\n// +build go1.4\n\npackage jwt\n\nimport (\n\t\"crypto\"\n\t\"crypto/rand\"\n\t\"crypto/rsa\"\n)\n\n// SigningMethodRSAPSS implements the RSAPSS family of signing methods signing methods\ntype SigningMethodRSAPSS struct {\n\t*SigningMethodRSA\n\tOptions *rsa.PSSOptions\n\t// VerifyOptions is optional. If set overrides Options for rsa.VerifyPPS.\n\t// Used to accept tokens signed with rsa.PSSSaltLengthAuto, what doesn't follow\n\t// https://tools.ietf.org/html/rfc7518#section-3.5 but was used previously.\n\t// See https://github.com/dgrijalva/jwt-go/issues/285#issuecomment-437451244 for details.\n\tVerifyOptions *rsa.PSSOptions\n}\n\n// Specific instances for RS/PS and company.\nvar (\n\tSigningMethodPS256 *SigningMethodRSAPSS\n\tSigningMethodPS384 *SigningMethodRSAPSS\n\tSigningMethodPS512 *SigningMethodRSAPSS\n)\n\nfunc init() {\n\t// PS256\n\tSigningMethodPS256 = &SigningMethodRSAPSS{\n\t\tSigningMethodRSA: &SigningMethodRSA{\n\t\t\tName: \"PS256\",\n\t\t\tHash: crypto.SHA256,\n\t\t},\n\t\tOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthEqualsHash,\n\t\t},\n\t\tVerifyOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthAuto,\n\t\t},\n\t}\n\tRegisterSigningMethod(SigningMethodPS256.Alg(), func() SigningMethod {\n\t\treturn SigningMethodPS256\n\t})\n\n\t// PS384\n\tSigningMethodPS384 = &SigningMethodRSAPSS{\n\t\tSigningMethodRSA: &SigningMethodRSA{\n\t\t\tName: \"PS384\",\n\t\t\tHash: crypto.SHA384,\n\t\t},\n\t\tOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthEqualsHash,\n\t\t},\n\t\tVerifyOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthAuto,\n\t\t},\n\t}\n\tRegisterSigningMethod(SigningMethodPS384.Alg(), func() SigningMethod {\n\t\treturn SigningMethodPS384\n\t})\n\n\t// PS512\n\tSigningMethodPS512 = &SigningMethodRSAPSS{\n\t\tSigningMethodRSA: &SigningMethodRSA{\n\t\t\tName: \"PS512\",\n\t\t\tHash: crypto.SHA512,\n\t\t},\n\t\tOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthEqualsHash,\n\t\t},\n\t\tVerifyOptions: &rsa.PSSOptions{\n\t\t\tSaltLength: rsa.PSSSaltLengthAuto,\n\t\t},\n\t}\n\tRegisterSigningMethod(SigningMethodPS512.Alg(), func() SigningMethod {\n\t\treturn SigningMethodPS512\n\t})\n}\n\n// Verify implements token verification for the SigningMethod.\n// For this verify method, key must be an rsa.PublicKey struct\nfunc (m *SigningMethodRSAPSS) Verify(signingString, signature string, key interface{}) error {\n\tvar err error\n\n\t// Decode the signature\n\tvar sig []byte\n\tif sig, err = DecodeSegment(signature); err != nil {\n\t\treturn err\n\t}\n\n\tvar rsaKey *rsa.PublicKey\n\tswitch k := key.(type) {\n\tcase *rsa.PublicKey:\n\t\trsaKey = k\n\tdefault:\n\t\treturn ErrInvalidKey\n\t}\n\n\t// Create hasher\n\tif !m.Hash.Available() {\n\t\treturn ErrHashUnavailable\n\t}\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\topts := m.Options\n\tif m.VerifyOptions != nil {\n\t\topts = m.VerifyOptions\n\t}\n\n\treturn rsa.VerifyPSS(rsaKey, m.Hash, hasher.Sum(nil), sig, opts)\n}\n\n// Sign implements token signing for the SigningMethod.\n// For this signing method, key must be an rsa.PrivateKey struct\nfunc (m *SigningMethodRSAPSS) Sign(signingString string, key interface{}) (string, error) {\n\tvar rsaKey *rsa.PrivateKey\n\n\tswitch k := key.(type) {\n\tcase *rsa.PrivateKey:\n\t\trsaKey = k\n\tdefault:\n\t\treturn \"\", ErrInvalidKeyType\n\t}\n\n\t// Create the hasher\n\tif !m.Hash.Available() {\n\t\treturn \"\", ErrHashUnavailable\n\t}\n\n\thasher := m.Hash.New()\n\thasher.Write([]byte(signingString))\n\n\t// Sign the string and return the encoded bytes\n\tif sigBytes, err := rsa.SignPSS(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil), m.Options); err == nil {\n\t\treturn EncodeSegment(sigBytes), nil\n\t} else {\n\t\treturn \"\", err\n\t}\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/rsa_utils.go",
"content": "package jwt\n\nimport (\n\t\"crypto/rsa\"\n\t\"crypto/x509\"\n\t\"encoding/pem\"\n\t\"errors\"\n)\n\nvar (\n\tErrKeyMustBePEMEncoded = errors.New(\"invalid key: Key must be a PEM encoded PKCS1 or PKCS8 key\")\n\tErrNotRSAPrivateKey = errors.New(\"key is not a valid RSA private key\")\n\tErrNotRSAPublicKey = errors.New(\"key is not a valid RSA public key\")\n)\n\n// ParseRSAPrivateKeyFromPEM parses a PEM encoded PKCS1 or PKCS8 private key\nfunc ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {\n\t\tif parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tvar pkey *rsa.PrivateKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {\n\t\treturn nil, ErrNotRSAPrivateKey\n\t}\n\n\treturn pkey, nil\n}\n\n// ParseRSAPrivateKeyFromPEMWithPassword parses a PEM encoded PKCS1 or PKCS8 private key protected with password\n//\n// Deprecated: This function is deprecated and should not be used anymore. It uses the deprecated x509.DecryptPEMBlock\n// function, which was deprecated since RFC 1423 is regarded insecure by design. Unfortunately, there is no alternative\n// in the Go standard library for now. See https://github.com/golang/go/issues/8860.\nfunc ParseRSAPrivateKeyFromPEMWithPassword(key []byte, password string) (*rsa.PrivateKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\tvar parsedKey interface{}\n\n\tvar blockDecrypted []byte\n\tif blockDecrypted, err = x509.DecryptPEMBlock(block, []byte(password)); err != nil {\n\t\treturn nil, err\n\t}\n\n\tif parsedKey, err = x509.ParsePKCS1PrivateKey(blockDecrypted); err != nil {\n\t\tif parsedKey, err = x509.ParsePKCS8PrivateKey(blockDecrypted); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tvar pkey *rsa.PrivateKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {\n\t\treturn nil, ErrNotRSAPrivateKey\n\t}\n\n\treturn pkey, nil\n}\n\n// ParseRSAPublicKeyFromPEM parses a PEM encoded PKCS1 or PKCS8 public key\nfunc ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error) {\n\tvar err error\n\n\t// Parse PEM block\n\tvar block *pem.Block\n\tif block, _ = pem.Decode(key); block == nil {\n\t\treturn nil, ErrKeyMustBePEMEncoded\n\t}\n\n\t// Parse the key\n\tvar parsedKey interface{}\n\tif parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {\n\t\tif cert, err := x509.ParseCertificate(block.Bytes); err == nil {\n\t\t\tparsedKey = cert.PublicKey\n\t\t} else {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tvar pkey *rsa.PublicKey\n\tvar ok bool\n\tif pkey, ok = parsedKey.(*rsa.PublicKey); !ok {\n\t\treturn nil, ErrNotRSAPublicKey\n\t}\n\n\treturn pkey, nil\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/signing_method.go",
"content": "package jwt\n\nimport (\n\t\"sync\"\n)\n\nvar signingMethods = map[string]func() SigningMethod{}\nvar signingMethodLock = new(sync.RWMutex)\n\n// SigningMethod can be used add new methods for signing or verifying tokens.\ntype SigningMethod interface {\n\tVerify(signingString, signature string, key interface{}) error // Returns nil if signature is valid\n\tSign(signingString string, key interface{}) (string, error) // Returns encoded signature or error\n\tAlg() string // returns the alg identifier for this method (example: 'HS256')\n}\n\n// RegisterSigningMethod registers the \"alg\" name and a factory function for signing method.\n// This is typically done during init() in the method's implementation\nfunc RegisterSigningMethod(alg string, f func() SigningMethod) {\n\tsigningMethodLock.Lock()\n\tdefer signingMethodLock.Unlock()\n\n\tsigningMethods[alg] = f\n}\n\n// GetSigningMethod retrieves a signing method from an \"alg\" string\nfunc GetSigningMethod(alg string) (method SigningMethod) {\n\tsigningMethodLock.RLock()\n\tdefer signingMethodLock.RUnlock()\n\n\tif methodF, ok := signingMethods[alg]; ok {\n\t\tmethod = methodF()\n\t}\n\treturn\n}\n\n// GetAlgorithms returns a list of registered \"alg\" names\nfunc GetAlgorithms() (algs []string) {\n\tsigningMethodLock.RLock()\n\tdefer signingMethodLock.RUnlock()\n\n\tfor alg := range signingMethods {\n\t\talgs = append(algs, alg)\n\t}\n\treturn\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/staticcheck.conf",
"content": "checks = [\"all\", \"-ST1000\", \"-ST1003\", \"-ST1016\", \"-ST1023\"]\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/token.go",
"content": "package jwt\n\nimport (\n\t\"encoding/base64\"\n\t\"encoding/json\"\n\t\"strings\"\n\t\"time\"\n)\n\n// DecodePaddingAllowed will switch the codec used for decoding JWTs respectively. Note that the JWS RFC7515\n// states that the tokens will utilize a Base64url encoding with no padding. Unfortunately, some implementations\n// of JWT are producing non-standard tokens, and thus require support for decoding. Note that this is a global\n// variable, and updating it will change the behavior on a package level, and is also NOT go-routine safe.\n// To use the non-recommended decoding, set this boolean to `true` prior to using this package.\nvar DecodePaddingAllowed bool\n\n// DecodeStrict will switch the codec used for decoding JWTs into strict mode.\n// In this mode, the decoder requires that trailing padding bits are zero, as described in RFC 4648 section 3.5.\n// Note that this is a global variable, and updating it will change the behavior on a package level, and is also NOT go-routine safe.\n// To use strict decoding, set this boolean to `true` prior to using this package.\nvar DecodeStrict bool\n\n// TimeFunc provides the current time when parsing token to validate \"exp\" claim (expiration time).\n// You can override it to use another time value. This is useful for testing or if your\n// server uses a different time zone than your tokens.\nvar TimeFunc = time.Now\n\n// Keyfunc will be used by the Parse methods as a callback function to supply\n// the key for verification. The function receives the parsed,\n// but unverified Token. This allows you to use properties in the\n// Header of the token (such as `kid`) to identify which key to use.\ntype Keyfunc func(*Token) (interface{}, error)\n\n// Token represents a JWT Token. Different fields will be used depending on whether you're\n// creating or parsing/verifying a token.\ntype Token struct {\n\tRaw string // The raw token. Populated when you Parse a token\n\tMethod SigningMethod // The signing method used or to be used\n\tHeader map[string]interface{} // The first segment of the token\n\tClaims Claims // The second segment of the token\n\tSignature string // The third segment of the token. Populated when you Parse a token\n\tValid bool // Is the token valid? Populated when you Parse/Verify a token\n}\n\n// New creates a new Token with the specified signing method and an empty map of claims.\nfunc New(method SigningMethod) *Token {\n\treturn NewWithClaims(method, MapClaims{})\n}\n\n// NewWithClaims creates a new Token with the specified signing method and claims.\nfunc NewWithClaims(method SigningMethod, claims Claims) *Token {\n\treturn &Token{\n\t\tHeader: map[string]interface{}{\n\t\t\t\"typ\": \"JWT\",\n\t\t\t\"alg\": method.Alg(),\n\t\t},\n\t\tClaims: claims,\n\t\tMethod: method,\n\t}\n}\n\n// SignedString creates and returns a complete, signed JWT.\n// The token is signed using the SigningMethod specified in the token.\nfunc (t *Token) SignedString(key interface{}) (string, error) {\n\tvar sig, sstr string\n\tvar err error\n\tif sstr, err = t.SigningString(); err != nil {\n\t\treturn \"\", err\n\t}\n\tif sig, err = t.Method.Sign(sstr, key); err != nil {\n\t\treturn \"\", err\n\t}\n\treturn strings.Join([]string{sstr, sig}, \".\"), nil\n}\n\n// SigningString generates the signing string. This is the\n// most expensive part of the whole deal. Unless you\n// need this for something special, just go straight for\n// the SignedString.\nfunc (t *Token) SigningString() (string, error) {\n\tvar err error\n\tvar jsonValue []byte\n\n\tif jsonValue, err = json.Marshal(t.Header); err != nil {\n\t\treturn \"\", err\n\t}\n\theader := EncodeSegment(jsonValue)\n\n\tif jsonValue, err = json.Marshal(t.Claims); err != nil {\n\t\treturn \"\", err\n\t}\n\tclaim := EncodeSegment(jsonValue)\n\n\treturn strings.Join([]string{header, claim}, \".\"), nil\n}\n\n// Parse parses, validates, verifies the signature and returns the parsed token.\n// keyFunc will receive the parsed token and should return the cryptographic key\n// for verifying the signature.\n// The caller is strongly encouraged to set the WithValidMethods option to\n// validate the 'alg' claim in the token matches the expected algorithm.\n// For more details about the importance of validating the 'alg' claim,\n// see https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/\nfunc Parse(tokenString string, keyFunc Keyfunc, options ...ParserOption) (*Token, error) {\n\treturn NewParser(options...).Parse(tokenString, keyFunc)\n}\n\n// ParseWithClaims is a shortcut for NewParser().ParseWithClaims().\n//\n// Note: If you provide a custom claim implementation that embeds one of the standard claims (such as RegisteredClaims),\n// make sure that a) you either embed a non-pointer version of the claims or b) if you are using a pointer, allocate the\n// proper memory for it before passing in the overall claims, otherwise you might run into a panic.\nfunc ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc, options ...ParserOption) (*Token, error) {\n\treturn NewParser(options...).ParseWithClaims(tokenString, claims, keyFunc)\n}\n\n// EncodeSegment encodes a JWT specific base64url encoding with padding stripped\n//\n// Deprecated: In a future release, we will demote this function to a non-exported function, since it\n// should only be used internally\nfunc EncodeSegment(seg []byte) string {\n\treturn base64.RawURLEncoding.EncodeToString(seg)\n}\n\n// DecodeSegment decodes a JWT specific base64url encoding with padding stripped\n//\n// Deprecated: In a future release, we will demote this function to a non-exported function, since it\n// should only be used internally\nfunc DecodeSegment(seg string) ([]byte, error) {\n\tencoding := base64.RawURLEncoding\n\n\tif DecodePaddingAllowed {\n\t\tif l := len(seg) % 4; l > 0 {\n\t\t\tseg += strings.Repeat(\"=\", 4-l)\n\t\t}\n\t\tencoding = base64.URLEncoding\n\t}\n\n\tif DecodeStrict {\n\t\tencoding = encoding.Strict()\n\t}\n\treturn encoding.DecodeString(seg)\n}\n"
},
{
"path": "vendor/github.com/golang-jwt/jwt/v4/types.go",
"content": "package jwt\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\t\"strconv\"\n\t\"time\"\n)\n\n// TimePrecision sets the precision of times and dates within this library.\n// This has an influence on the precision of times when comparing expiry or\n// other related time fields. Furthermore, it is also the precision of times\n// when serializing.\n//\n// For backwards compatibility the default precision is set to seconds, so that\n// no fractional timestamps are generated.\nvar TimePrecision = time.Second\n\n// MarshalSingleStringAsArray modifies the behaviour of the ClaimStrings type, especially\n// its MarshalJSON function.\n//\n// If it is set to true (the default), it will always serialize the type as an\n// array of strings, even if it just contains one element, defaulting to the behaviour\n// of the underlying []string. If it is set to false, it will serialize to a single\n// string, if it contains one element. Otherwise, it will serialize to an array of strings.\nvar MarshalSingleStringAsArray = true\n\n// NumericDate represents a JSON numeric date value, as referenced at\n// https://datatracker.ietf.org/doc/html/rfc7519#section-2.\ntype NumericDate struct {\n\ttime.Time\n}\n\n// NewNumericDate constructs a new *NumericDate from a standard library time.Time struct.\n// It will truncate the timestamp according to the precision specified in TimePrecision.\nfunc NewNumericDate(t time.Time) *NumericDate {\n\treturn &NumericDate{t.Truncate(TimePrecision)}\n}\n\n// newNumericDateFromSeconds creates a new *NumericDate out of a float64 representing a\n// UNIX epoch with the float fraction representing non-integer seconds.\nfunc newNumericDateFromSeconds(f float64) *NumericDate {\n\tround, frac := math.Modf(f)\n\treturn NewNumericDate(time.Unix(int64(round), int64(frac*1e9)))\n}\n\n// MarshalJSON is an implementation of the json.RawMessage interface and serializes the UNIX epoch\n// represented in NumericDate to a byte array, using the precision specified in TimePrecision.\nfunc (date NumericDate) MarshalJSON() (b []byte, err error) {\n\tvar prec int\n\tif TimePrecision < time.Second {\n\t\tprec = int(math.Log10(float64(time.Second) / float64(TimePrecision)))\n\t}\n\ttruncatedDate := date.Truncate(TimePrecision)\n\n\t// For very large timestamps, UnixNano would overflow an int64, but this\n\t// function requires nanosecond level precision, so we have to use the\n\t// following technique to get round the issue:\n\t// 1. Take the normal unix timestamp to form the whole number part of the\n\t// output,\n\t// 2. Take the result of the Nanosecond function, which retuns the offset\n\t// within the second of the particular unix time instance, to form the\n\t// decimal part of the output\n\t// 3. Concatenate them to produce the final result\n\tseconds := strconv.FormatInt(truncatedDate.Unix(), 10)\n\tnanosecondsOffset := strconv.FormatFloat(float64(truncatedDate.Nanosecond())/float64(time.Second), 'f', prec, 64)\n\n\toutput := append([]byte(seconds), []byte(nanosecondsOffset)[1:]...)\n\n\treturn output, nil\n}\n\n// UnmarshalJSON is an implementation of the json.RawMessage interface and deserializses a\n// NumericDate from a JSON representation, i.e. a json.Number. This number represents an UNIX epoch\n// with either integer or non-integer seconds.\nfunc (date *NumericDate) UnmarshalJSON(b []byte) (err error) {\n\tvar (\n\t\tnumber json.Number\n\t\tf float64\n\t)\n\n\tif err = json.Unmarshal(b, &number); err != nil {\n\t\treturn fmt.Errorf(\"could not parse NumericData: %w\", err)\n\t}\n\n\tif f, err = number.Float64(); err != nil {\n\t\treturn fmt.Errorf(\"could not convert json number value to float: %w\", err)\n\t}\n\n\tn := newNumericDateFromSeconds(f)\n\t*date = *n\n\n\treturn nil\n}\n\n// ClaimStrings is basically just a slice of strings, but it can be either serialized from a string array or just a string.\n// This type is necessary, since the \"aud\" claim can either be a single string or an array.\ntype ClaimStrings []string\n\nfunc (s *ClaimStrings) UnmarshalJSON(data []byte) (err error) {\n\tvar value interface{}\n\n\tif err = json.Unmarshal(data, &value); err != nil {\n\t\treturn err\n\t}\n\n\tvar aud []string\n\n\tswitch v := value.(type) {\n\tcase string:\n\t\taud = append(aud, v)\n\tcase []string:\n\t\taud = ClaimStrings(v)\n\tcase []interface{}:\n\t\tfor _, vv := range v {\n\t\t\tvs, ok := vv.(string)\n\t\t\tif !ok {\n\t\t\t\treturn &json.UnsupportedTypeError{Type: reflect.TypeOf(vv)}\n\t\t\t}\n\t\t\taud = append(aud, vs)\n\t\t}\n\tcase nil:\n\t\treturn nil\n\tdefault:\n\t\treturn &json.UnsupportedTypeError{Type: reflect.TypeOf(v)}\n\t}\n\n\t*s = aud\n\n\treturn\n}\n\nfunc (s ClaimStrings) MarshalJSON() (b []byte, err error) {\n\t// This handles a special case in the JWT RFC. If the string array, e.g. used by the \"aud\" field,\n\t// only contains one element, it MAY be serialized as a single string. This may or may not be\n\t// desired based on the ecosystem of other JWT library used, so we make it configurable by the\n\t// variable MarshalSingleStringAsArray.\n\tif len(s) == 1 && !MarshalSingleStringAsArray {\n\t\treturn json.Marshal(s[0])\n\t}\n\n\treturn json.Marshal([]string(s))\n}\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE",
"content": "Copyright 2012 Matt T. Proud (matt.proud@gmail.com)\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/.gitignore",
"content": "cover.dat\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/Makefile",
"content": "all:\n\ncover:\n\tgo test -cover -v -coverprofile=cover.dat ./...\n\tgo tool cover -func cover.dat\n\n.PHONY: cover\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go",
"content": "// Copyright 2013 Matt T. Proud\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage pbutil\n\nimport (\n\t\"encoding/binary\"\n\t\"errors\"\n\t\"io\"\n\n\t\"github.com/golang/protobuf/proto\"\n)\n\nvar errInvalidVarint = errors.New(\"invalid varint32 encountered\")\n\n// ReadDelimited decodes a message from the provided length-delimited stream,\n// where the length is encoded as 32-bit varint prefix to the message body.\n// It returns the total number of bytes read and any applicable error. This is\n// roughly equivalent to the companion Java API's\n// MessageLite#parseDelimitedFrom. As per the reader contract, this function\n// calls r.Read repeatedly as required until exactly one message including its\n// prefix is read and decoded (or an error has occurred). The function never\n// reads more bytes from the stream than required. The function never returns\n// an error if a message has been read and decoded correctly, even if the end\n// of the stream has been reached in doing so. In that case, any subsequent\n// calls return (0, io.EOF).\nfunc ReadDelimited(r io.Reader, m proto.Message) (n int, err error) {\n\t// Per AbstractParser#parsePartialDelimitedFrom with\n\t// CodedInputStream#readRawVarint32.\n\tvar headerBuf [binary.MaxVarintLen32]byte\n\tvar bytesRead, varIntBytes int\n\tvar messageLength uint64\n\tfor varIntBytes == 0 { // i.e. no varint has been decoded yet.\n\t\tif bytesRead >= len(headerBuf) {\n\t\t\treturn bytesRead, errInvalidVarint\n\t\t}\n\t\t// We have to read byte by byte here to avoid reading more bytes\n\t\t// than required. Each read byte is appended to what we have\n\t\t// read before.\n\t\tnewBytesRead, err := r.Read(headerBuf[bytesRead : bytesRead+1])\n\t\tif newBytesRead == 0 {\n\t\t\tif err != nil {\n\t\t\t\treturn bytesRead, err\n\t\t\t}\n\t\t\t// A Reader should not return (0, nil), but if it does,\n\t\t\t// it should be treated as no-op (according to the\n\t\t\t// Reader contract). So let's go on...\n\t\t\tcontinue\n\t\t}\n\t\tbytesRead += newBytesRead\n\t\t// Now present everything read so far to the varint decoder and\n\t\t// see if a varint can be decoded already.\n\t\tmessageLength, varIntBytes = proto.DecodeVarint(headerBuf[:bytesRead])\n\t}\n\n\tmessageBuf := make([]byte, messageLength)\n\tnewBytesRead, err := io.ReadFull(r, messageBuf)\n\tbytesRead += newBytesRead\n\tif err != nil {\n\t\treturn bytesRead, err\n\t}\n\n\treturn bytesRead, proto.Unmarshal(messageBuf, m)\n}\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go",
"content": "// Copyright 2013 Matt T. Proud\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package pbutil provides record length-delimited Protocol Buffer streaming.\npackage pbutil\n"
},
{
"path": "vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go",
"content": "// Copyright 2013 Matt T. Proud\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage pbutil\n\nimport (\n\t\"encoding/binary\"\n\t\"io\"\n\n\t\"github.com/golang/protobuf/proto\"\n)\n\n// WriteDelimited encodes and dumps a message to the provided writer prefixed\n// with a 32-bit varint indicating the length of the encoded message, producing\n// a length-delimited record stream, which can be used to chain together\n// encoded messages of the same type together in a file. It returns the total\n// number of bytes written and any applicable error. This is roughly\n// equivalent to the companion Java API's MessageLite#writeDelimitedTo.\nfunc WriteDelimited(w io.Writer, m proto.Message) (n int, err error) {\n\tbuffer, err := proto.Marshal(m)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\tvar buf [binary.MaxVarintLen32]byte\n\tencodedLength := binary.PutUvarint(buf[:], uint64(len(buffer)))\n\n\tsync, err := w.Write(buf[:encodedLength])\n\tif err != nil {\n\t\treturn sync, err\n\t}\n\n\tn, err = w.Write(buffer)\n\treturn n + sync, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/NOTICE",
"content": "Prometheus instrumentation library for Go applications\nCopyright 2012-2015 The Prometheus Authors\n\nThis product includes software developed at\nSoundCloud Ltd. (http://soundcloud.com/).\n\n\nThe following components are included in this product:\n\nperks - a fork of https://github.com/bmizerany/perks\nhttps://github.com/beorn7/perks\nCopyright 2013-2015 Blake Mizerany, Björn Rabenstein\nSee https://github.com/beorn7/perks/blob/master/README.md for license details.\n\nGo support for Protocol Buffers - Google's data interchange format\nhttp://github.com/golang/protobuf/\nCopyright 2010 The Go Authors\nSee source code for license details.\n\nSupport for streaming Protocol Buffer messages for the Go language (golang).\nhttps://github.com/matttproud/golang_protobuf_extensions\nCopyright 2013 Matt T. Proud\nLicensed under the Apache License, Version 2.0\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/.gitignore",
"content": "command-line-arguments.test\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/README.md",
"content": "See [](https://pkg.go.dev/github.com/prometheus/client_golang/prometheus).\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/build_info_collector.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport \"runtime/debug\"\n\n// NewBuildInfoCollector is the obsolete version of collectors.NewBuildInfoCollector.\n// See there for documentation.\n//\n// Deprecated: Use collectors.NewBuildInfoCollector instead.\nfunc NewBuildInfoCollector() Collector {\n\tpath, version, sum := \"unknown\", \"unknown\", \"unknown\"\n\tif bi, ok := debug.ReadBuildInfo(); ok {\n\t\tpath = bi.Main.Path\n\t\tversion = bi.Main.Version\n\t\tsum = bi.Main.Sum\n\t}\n\tc := &selfCollector{MustNewConstMetric(\n\t\tNewDesc(\n\t\t\t\"go_build_info\",\n\t\t\t\"Build information about the main Go module.\",\n\t\t\tnil, Labels{\"path\": path, \"version\": version, \"checksum\": sum},\n\t\t),\n\t\tGaugeValue, 1)}\n\tc.init(c.self)\n\treturn c\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/collector.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\n// Collector is the interface implemented by anything that can be used by\n// Prometheus to collect metrics. A Collector has to be registered for\n// collection. See Registerer.Register.\n//\n// The stock metrics provided by this package (Gauge, Counter, Summary,\n// Histogram, Untyped) are also Collectors (which only ever collect one metric,\n// namely itself). An implementer of Collector may, however, collect multiple\n// metrics in a coordinated fashion and/or create metrics on the fly. Examples\n// for collectors already implemented in this library are the metric vectors\n// (i.e. collection of multiple instances of the same Metric but with different\n// label values) like GaugeVec or SummaryVec, and the ExpvarCollector.\ntype Collector interface {\n\t// Describe sends the super-set of all possible descriptors of metrics\n\t// collected by this Collector to the provided channel and returns once\n\t// the last descriptor has been sent. The sent descriptors fulfill the\n\t// consistency and uniqueness requirements described in the Desc\n\t// documentation.\n\t//\n\t// It is valid if one and the same Collector sends duplicate\n\t// descriptors. Those duplicates are simply ignored. However, two\n\t// different Collectors must not send duplicate descriptors.\n\t//\n\t// Sending no descriptor at all marks the Collector as “unchecked”,\n\t// i.e. no checks will be performed at registration time, and the\n\t// Collector may yield any Metric it sees fit in its Collect method.\n\t//\n\t// This method idempotently sends the same descriptors throughout the\n\t// lifetime of the Collector. It may be called concurrently and\n\t// therefore must be implemented in a concurrency safe way.\n\t//\n\t// If a Collector encounters an error while executing this method, it\n\t// must send an invalid descriptor (created with NewInvalidDesc) to\n\t// signal the error to the registry.\n\tDescribe(chan<- *Desc)\n\t// Collect is called by the Prometheus registry when collecting\n\t// metrics. The implementation sends each collected metric via the\n\t// provided channel and returns once the last metric has been sent. The\n\t// descriptor of each sent metric is one of those returned by Describe\n\t// (unless the Collector is unchecked, see above). Returned metrics that\n\t// share the same descriptor must differ in their variable label\n\t// values.\n\t//\n\t// This method may be called concurrently and must therefore be\n\t// implemented in a concurrency safe way. Blocking occurs at the expense\n\t// of total performance of rendering all registered metrics. Ideally,\n\t// Collector implementations support concurrent readers.\n\tCollect(chan<- Metric)\n}\n\n// DescribeByCollect is a helper to implement the Describe method of a custom\n// Collector. It collects the metrics from the provided Collector and sends\n// their descriptors to the provided channel.\n//\n// If a Collector collects the same metrics throughout its lifetime, its\n// Describe method can simply be implemented as:\n//\n//\tfunc (c customCollector) Describe(ch chan<- *Desc) {\n//\t\tDescribeByCollect(c, ch)\n//\t}\n//\n// However, this will not work if the metrics collected change dynamically over\n// the lifetime of the Collector in a way that their combined set of descriptors\n// changes as well. The shortcut implementation will then violate the contract\n// of the Describe method. If a Collector sometimes collects no metrics at all\n// (for example vectors like CounterVec, GaugeVec, etc., which only collect\n// metrics after a metric with a fully specified label set has been accessed),\n// it might even get registered as an unchecked Collector (cf. the Register\n// method of the Registerer interface). Hence, only use this shortcut\n// implementation of Describe if you are certain to fulfill the contract.\n//\n// The Collector example demonstrates a use of DescribeByCollect.\nfunc DescribeByCollect(c Collector, descs chan<- *Desc) {\n\tmetrics := make(chan Metric)\n\tgo func() {\n\t\tc.Collect(metrics)\n\t\tclose(metrics)\n\t}()\n\tfor m := range metrics {\n\t\tdescs <- m.Desc()\n\t}\n}\n\n// selfCollector implements Collector for a single Metric so that the Metric\n// collects itself. Add it as an anonymous field to a struct that implements\n// Metric, and call init with the Metric itself as an argument.\ntype selfCollector struct {\n\tself Metric\n}\n\n// init provides the selfCollector with a reference to the metric it is supposed\n// to collect. It is usually called within the factory function to create a\n// metric. See example.\nfunc (c *selfCollector) init(self Metric) {\n\tc.self = self\n}\n\n// Describe implements Collector.\nfunc (c *selfCollector) Describe(ch chan<- *Desc) {\n\tch <- c.self.Desc()\n}\n\n// Collect implements Collector.\nfunc (c *selfCollector) Collect(ch chan<- Metric) {\n\tch <- c.self\n}\n\n// collectorMetric is a metric that is also a collector.\n// Because of selfCollector, most (if not all) Metrics in\n// this package are also collectors.\ntype collectorMetric interface {\n\tMetric\n\tCollector\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/counter.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"errors\"\n\t\"math\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// Counter is a Metric that represents a single numerical value that only ever\n// goes up. That implies that it cannot be used to count items whose number can\n// also go down, e.g. the number of currently running goroutines. Those\n// \"counters\" are represented by Gauges.\n//\n// A Counter is typically used to count requests served, tasks completed, errors\n// occurred, etc.\n//\n// To create Counter instances, use NewCounter.\ntype Counter interface {\n\tMetric\n\tCollector\n\n\t// Inc increments the counter by 1. Use Add to increment it by arbitrary\n\t// non-negative values.\n\tInc()\n\t// Add adds the given value to the counter. It panics if the value is <\n\t// 0.\n\tAdd(float64)\n}\n\n// ExemplarAdder is implemented by Counters that offer the option of adding a\n// value to the Counter together with an exemplar. Its AddWithExemplar method\n// works like the Add method of the Counter interface but also replaces the\n// currently saved exemplar (if any) with a new one, created from the provided\n// value, the current time as timestamp, and the provided labels. Empty Labels\n// will lead to a valid (label-less) exemplar. But if Labels is nil, the current\n// exemplar is left in place. AddWithExemplar panics if the value is < 0, if any\n// of the provided labels are invalid, or if the provided labels contain more\n// than 128 runes in total.\ntype ExemplarAdder interface {\n\tAddWithExemplar(value float64, exemplar Labels)\n}\n\n// CounterOpts is an alias for Opts. See there for doc comments.\ntype CounterOpts Opts\n\n// NewCounter creates a new Counter based on the provided CounterOpts.\n//\n// The returned implementation also implements ExemplarAdder. It is safe to\n// perform the corresponding type assertion.\n//\n// The returned implementation tracks the counter value in two separate\n// variables, a float64 and a uint64. The latter is used to track calls of the\n// Inc method and calls of the Add method with a value that can be represented\n// as a uint64. This allows atomic increments of the counter with optimal\n// performance. (It is common to have an Inc call in very hot execution paths.)\n// Both internal tracking values are added up in the Write method. This has to\n// be taken into account when it comes to precision and overflow behavior.\nfunc NewCounter(opts CounterOpts) Counter {\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tnil,\n\t\topts.ConstLabels,\n\t)\n\tresult := &counter{desc: desc, labelPairs: desc.constLabelPairs, now: time.Now}\n\tresult.init(result) // Init self-collection.\n\treturn result\n}\n\ntype counter struct {\n\t// valBits contains the bits of the represented float64 value, while\n\t// valInt stores values that are exact integers. Both have to go first\n\t// in the struct to guarantee alignment for atomic operations.\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\tvalBits uint64\n\tvalInt uint64\n\n\tselfCollector\n\tdesc *Desc\n\n\tlabelPairs []*dto.LabelPair\n\texemplar atomic.Value // Containing nil or a *dto.Exemplar.\n\n\tnow func() time.Time // To mock out time.Now() for testing.\n}\n\nfunc (c *counter) Desc() *Desc {\n\treturn c.desc\n}\n\nfunc (c *counter) Add(v float64) {\n\tif v < 0 {\n\t\tpanic(errors.New(\"counter cannot decrease in value\"))\n\t}\n\n\tival := uint64(v)\n\tif float64(ival) == v {\n\t\tatomic.AddUint64(&c.valInt, ival)\n\t\treturn\n\t}\n\n\tfor {\n\t\toldBits := atomic.LoadUint64(&c.valBits)\n\t\tnewBits := math.Float64bits(math.Float64frombits(oldBits) + v)\n\t\tif atomic.CompareAndSwapUint64(&c.valBits, oldBits, newBits) {\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc (c *counter) AddWithExemplar(v float64, e Labels) {\n\tc.Add(v)\n\tc.updateExemplar(v, e)\n}\n\nfunc (c *counter) Inc() {\n\tatomic.AddUint64(&c.valInt, 1)\n}\n\nfunc (c *counter) get() float64 {\n\tfval := math.Float64frombits(atomic.LoadUint64(&c.valBits))\n\tival := atomic.LoadUint64(&c.valInt)\n\treturn fval + float64(ival)\n}\n\nfunc (c *counter) Write(out *dto.Metric) error {\n\t// Read the Exemplar first and the value second. This is to avoid a race condition\n\t// where users see an exemplar for a not-yet-existing observation.\n\tvar exemplar *dto.Exemplar\n\tif e := c.exemplar.Load(); e != nil {\n\t\texemplar = e.(*dto.Exemplar)\n\t}\n\tval := c.get()\n\n\treturn populateMetric(CounterValue, val, c.labelPairs, exemplar, out)\n}\n\nfunc (c *counter) updateExemplar(v float64, l Labels) {\n\tif l == nil {\n\t\treturn\n\t}\n\te, err := newExemplar(v, c.now(), l)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\tc.exemplar.Store(e)\n}\n\n// CounterVec is a Collector that bundles a set of Counters that all share the\n// same Desc, but have different values for their variable labels. This is used\n// if you want to count the same thing partitioned by various dimensions\n// (e.g. number of HTTP requests, partitioned by response code and\n// method). Create instances with NewCounterVec.\ntype CounterVec struct {\n\t*MetricVec\n}\n\n// NewCounterVec creates a new CounterVec based on the provided CounterOpts and\n// partitioned by the given label names.\nfunc NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec {\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tlabelNames,\n\t\topts.ConstLabels,\n\t)\n\treturn &CounterVec{\n\t\tMetricVec: NewMetricVec(desc, func(lvs ...string) Metric {\n\t\t\tif len(lvs) != len(desc.variableLabels) {\n\t\t\t\tpanic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, lvs))\n\t\t\t}\n\t\t\tresult := &counter{desc: desc, labelPairs: MakeLabelPairs(desc, lvs), now: time.Now}\n\t\t\tresult.init(result) // Init self-collection.\n\t\t\treturn result\n\t\t}),\n\t}\n}\n\n// GetMetricWithLabelValues returns the Counter for the given slice of label\n// values (same order as the variable labels in Desc). If that combination of\n// label values is accessed for the first time, a new Counter is created.\n//\n// It is possible to call this method without using the returned Counter to only\n// create the new Counter but leave it at its starting value 0. See also the\n// SummaryVec example.\n//\n// Keeping the Counter for later use is possible (and should be considered if\n// performance is critical), but keep in mind that Reset, DeleteLabelValues and\n// Delete can be used to delete the Counter from the CounterVec. In that case,\n// the Counter will still exist, but it will not be exported anymore, even if a\n// Counter with the same label values is created later.\n//\n// An error is returned if the number of label values is not the same as the\n// number of variable labels in Desc (minus any curried labels).\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as\n// an alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\n// See also the GaugeVec example.\nfunc (v *CounterVec) GetMetricWithLabelValues(lvs ...string) (Counter, error) {\n\tmetric, err := v.MetricVec.GetMetricWithLabelValues(lvs...)\n\tif metric != nil {\n\t\treturn metric.(Counter), err\n\t}\n\treturn nil, err\n}\n\n// GetMetricWith returns the Counter for the given Labels map (the label names\n// must match those of the variable labels in Desc). If that label map is\n// accessed for the first time, a new Counter is created. Implications of\n// creating a Counter without using it and keeping the Counter for later use are\n// the same as for GetMetricWithLabelValues.\n//\n// An error is returned if the number and names of the Labels are inconsistent\n// with those of the variable labels in Desc (minus any curried labels).\n//\n// This method is used for the same purpose as\n// GetMetricWithLabelValues(...string). See there for pros and cons of the two\n// methods.\nfunc (v *CounterVec) GetMetricWith(labels Labels) (Counter, error) {\n\tmetric, err := v.MetricVec.GetMetricWith(labels)\n\tif metric != nil {\n\t\treturn metric.(Counter), err\n\t}\n\treturn nil, err\n}\n\n// WithLabelValues works as GetMetricWithLabelValues, but panics where\n// GetMetricWithLabelValues would have returned an error. Not returning an\n// error allows shortcuts like\n//\n//\tmyVec.WithLabelValues(\"404\", \"GET\").Add(42)\nfunc (v *CounterVec) WithLabelValues(lvs ...string) Counter {\n\tc, err := v.GetMetricWithLabelValues(lvs...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn c\n}\n\n// With works as GetMetricWith, but panics where GetMetricWithLabels would have\n// returned an error. Not returning an error allows shortcuts like\n//\n//\tmyVec.With(prometheus.Labels{\"code\": \"404\", \"method\": \"GET\"}).Add(42)\nfunc (v *CounterVec) With(labels Labels) Counter {\n\tc, err := v.GetMetricWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn c\n}\n\n// CurryWith returns a vector curried with the provided labels, i.e. the\n// returned vector has those labels pre-set for all labeled operations performed\n// on it. The cardinality of the curried vector is reduced accordingly. The\n// order of the remaining labels stays the same (just with the curried labels\n// taken out of the sequence – which is relevant for the\n// (GetMetric)WithLabelValues methods). It is possible to curry a curried\n// vector, but only with labels not yet used for currying before.\n//\n// The metrics contained in the CounterVec are shared between the curried and\n// uncurried vectors. They are just accessed differently. Curried and uncurried\n// vectors behave identically in terms of collection. Only one must be\n// registered with a given registry (usually the uncurried version). The Reset\n// method deletes all metrics, even if called on a curried vector.\nfunc (v *CounterVec) CurryWith(labels Labels) (*CounterVec, error) {\n\tvec, err := v.MetricVec.CurryWith(labels)\n\tif vec != nil {\n\t\treturn &CounterVec{vec}, err\n\t}\n\treturn nil, err\n}\n\n// MustCurryWith works as CurryWith but panics where CurryWith would have\n// returned an error.\nfunc (v *CounterVec) MustCurryWith(labels Labels) *CounterVec {\n\tvec, err := v.CurryWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn vec\n}\n\n// CounterFunc is a Counter whose value is determined at collect time by calling a\n// provided function.\n//\n// To create CounterFunc instances, use NewCounterFunc.\ntype CounterFunc interface {\n\tMetric\n\tCollector\n}\n\n// NewCounterFunc creates a new CounterFunc based on the provided\n// CounterOpts. The value reported is determined by calling the given function\n// from within the Write method. Take into account that metric collection may\n// happen concurrently. If that results in concurrent calls to Write, like in\n// the case where a CounterFunc is directly registered with Prometheus, the\n// provided function must be concurrency-safe. The function should also honor\n// the contract for a Counter (values only go up, not down), but compliance will\n// not be checked.\n//\n// Check out the ExampleGaugeFunc examples for the similar GaugeFunc.\nfunc NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc {\n\treturn newValueFunc(NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tnil,\n\t\topts.ConstLabels,\n\t), CounterValue, function)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/desc.go",
"content": "// Copyright 2016 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"sort\"\n\t\"strings\"\n\n\t\"github.com/cespare/xxhash/v2\"\n\n\t\"github.com/prometheus/client_golang/prometheus/internal\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\t\"github.com/prometheus/common/model\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// Desc is the descriptor used by every Prometheus Metric. It is essentially\n// the immutable meta-data of a Metric. The normal Metric implementations\n// included in this package manage their Desc under the hood. Users only have to\n// deal with Desc if they use advanced features like the ExpvarCollector or\n// custom Collectors and Metrics.\n//\n// Descriptors registered with the same registry have to fulfill certain\n// consistency and uniqueness criteria if they share the same fully-qualified\n// name: They must have the same help string and the same label names (aka label\n// dimensions) in each, constLabels and variableLabels, but they must differ in\n// the values of the constLabels.\n//\n// Descriptors that share the same fully-qualified names and the same label\n// values of their constLabels are considered equal.\n//\n// Use NewDesc to create new Desc instances.\ntype Desc struct {\n\t// fqName has been built from Namespace, Subsystem, and Name.\n\tfqName string\n\t// help provides some helpful information about this metric.\n\thelp string\n\t// constLabelPairs contains precalculated DTO label pairs based on\n\t// the constant labels.\n\tconstLabelPairs []*dto.LabelPair\n\t// variableLabels contains names of labels for which the metric\n\t// maintains variable values.\n\tvariableLabels []string\n\t// id is a hash of the values of the ConstLabels and fqName. This\n\t// must be unique among all registered descriptors and can therefore be\n\t// used as an identifier of the descriptor.\n\tid uint64\n\t// dimHash is a hash of the label names (preset and variable) and the\n\t// Help string. Each Desc with the same fqName must have the same\n\t// dimHash.\n\tdimHash uint64\n\t// err is an error that occurred during construction. It is reported on\n\t// registration time.\n\terr error\n}\n\n// NewDesc allocates and initializes a new Desc. Errors are recorded in the Desc\n// and will be reported on registration time. variableLabels and constLabels can\n// be nil if no such labels should be set. fqName must not be empty.\n//\n// variableLabels only contain the label names. Their label values are variable\n// and therefore not part of the Desc. (They are managed within the Metric.)\n//\n// For constLabels, the label values are constant. Therefore, they are fully\n// specified in the Desc. See the Collector example for a usage pattern.\nfunc NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *Desc {\n\td := &Desc{\n\t\tfqName: fqName,\n\t\thelp: help,\n\t\tvariableLabels: variableLabels,\n\t}\n\tif !model.IsValidMetricName(model.LabelValue(fqName)) {\n\t\td.err = fmt.Errorf(\"%q is not a valid metric name\", fqName)\n\t\treturn d\n\t}\n\t// labelValues contains the label values of const labels (in order of\n\t// their sorted label names) plus the fqName (at position 0).\n\tlabelValues := make([]string, 1, len(constLabels)+1)\n\tlabelValues[0] = fqName\n\tlabelNames := make([]string, 0, len(constLabels)+len(variableLabels))\n\tlabelNameSet := map[string]struct{}{}\n\t// First add only the const label names and sort them...\n\tfor labelName := range constLabels {\n\t\tif !checkLabelName(labelName) {\n\t\t\td.err = fmt.Errorf(\"%q is not a valid label name for metric %q\", labelName, fqName)\n\t\t\treturn d\n\t\t}\n\t\tlabelNames = append(labelNames, labelName)\n\t\tlabelNameSet[labelName] = struct{}{}\n\t}\n\tsort.Strings(labelNames)\n\t// ... so that we can now add const label values in the order of their names.\n\tfor _, labelName := range labelNames {\n\t\tlabelValues = append(labelValues, constLabels[labelName])\n\t}\n\t// Validate the const label values. They can't have a wrong cardinality, so\n\t// use in len(labelValues) as expectedNumberOfValues.\n\tif err := validateLabelValues(labelValues, len(labelValues)); err != nil {\n\t\td.err = err\n\t\treturn d\n\t}\n\t// Now add the variable label names, but prefix them with something that\n\t// cannot be in a regular label name. That prevents matching the label\n\t// dimension with a different mix between preset and variable labels.\n\tfor _, labelName := range variableLabels {\n\t\tif !checkLabelName(labelName) {\n\t\t\td.err = fmt.Errorf(\"%q is not a valid label name for metric %q\", labelName, fqName)\n\t\t\treturn d\n\t\t}\n\t\tlabelNames = append(labelNames, \"$\"+labelName)\n\t\tlabelNameSet[labelName] = struct{}{}\n\t}\n\tif len(labelNames) != len(labelNameSet) {\n\t\td.err = errors.New(\"duplicate label names\")\n\t\treturn d\n\t}\n\n\txxh := xxhash.New()\n\tfor _, val := range labelValues {\n\t\txxh.WriteString(val)\n\t\txxh.Write(separatorByteSlice)\n\t}\n\td.id = xxh.Sum64()\n\t// Sort labelNames so that order doesn't matter for the hash.\n\tsort.Strings(labelNames)\n\t// Now hash together (in this order) the help string and the sorted\n\t// label names.\n\txxh.Reset()\n\txxh.WriteString(help)\n\txxh.Write(separatorByteSlice)\n\tfor _, labelName := range labelNames {\n\t\txxh.WriteString(labelName)\n\t\txxh.Write(separatorByteSlice)\n\t}\n\td.dimHash = xxh.Sum64()\n\n\td.constLabelPairs = make([]*dto.LabelPair, 0, len(constLabels))\n\tfor n, v := range constLabels {\n\t\td.constLabelPairs = append(d.constLabelPairs, &dto.LabelPair{\n\t\t\tName: proto.String(n),\n\t\t\tValue: proto.String(v),\n\t\t})\n\t}\n\tsort.Sort(internal.LabelPairSorter(d.constLabelPairs))\n\treturn d\n}\n\n// NewInvalidDesc returns an invalid descriptor, i.e. a descriptor with the\n// provided error set. If a collector returning such a descriptor is registered,\n// registration will fail with the provided error. NewInvalidDesc can be used by\n// a Collector to signal inability to describe itself.\nfunc NewInvalidDesc(err error) *Desc {\n\treturn &Desc{\n\t\terr: err,\n\t}\n}\n\nfunc (d *Desc) String() string {\n\tlpStrings := make([]string, 0, len(d.constLabelPairs))\n\tfor _, lp := range d.constLabelPairs {\n\t\tlpStrings = append(\n\t\t\tlpStrings,\n\t\t\tfmt.Sprintf(\"%s=%q\", lp.GetName(), lp.GetValue()),\n\t\t)\n\t}\n\treturn fmt.Sprintf(\n\t\t\"Desc{fqName: %q, help: %q, constLabels: {%s}, variableLabels: %v}\",\n\t\td.fqName,\n\t\td.help,\n\t\tstrings.Join(lpStrings, \",\"),\n\t\td.variableLabels,\n\t)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/doc.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package prometheus is the core instrumentation package. It provides metrics\n// primitives to instrument code for monitoring. It also offers a registry for\n// metrics. Sub-packages allow to expose the registered metrics via HTTP\n// (package promhttp) or push them to a Pushgateway (package push). There is\n// also a sub-package promauto, which provides metrics constructors with\n// automatic registration.\n//\n// All exported functions and methods are safe to be used concurrently unless\n// specified otherwise.\n//\n// # A Basic Example\n//\n// As a starting point, a very basic usage example:\n//\n//\tpackage main\n//\n//\timport (\n//\t\t\"log\"\n//\t\t\"net/http\"\n//\n//\t\t\"github.com/prometheus/client_golang/prometheus\"\n//\t\t\"github.com/prometheus/client_golang/prometheus/promhttp\"\n//\t)\n//\n//\ttype metrics struct {\n//\t\tcpuTemp prometheus.Gauge\n//\t hdFailures *prometheus.CounterVec\n//\t}\n//\n//\tfunc NewMetrics(reg prometheus.Registerer) *metrics {\n//\t m := &metrics{\n//\t cpuTemp: prometheus.NewGauge(prometheus.GaugeOpts{\n//\t Name: \"cpu_temperature_celsius\",\n//\t Help: \"Current temperature of the CPU.\",\n//\t }),\n//\t hdFailures: prometheus.NewCounterVec(\n//\t prometheus.CounterOpts{\n//\t Name: \"hd_errors_total\",\n//\t Help: \"Number of hard-disk errors.\",\n//\t },\n//\t []string{\"device\"},\n//\t ),\n//\t }\n//\t reg.MustRegister(m.cpuTemp)\n//\t reg.MustRegister(m.hdFailures)\n//\t return m\n//\t}\n//\n//\tfunc main() {\n//\t // Create a non-global registry.\n//\t reg := prometheus.NewRegistry()\n//\n//\t // Create new metrics and register them using the custom registry.\n//\t m := NewMetrics(reg)\n//\t // Set values for the new created metrics.\n//\t\tm.cpuTemp.Set(65.3)\n//\t\tm.hdFailures.With(prometheus.Labels{\"device\":\"/dev/sda\"}).Inc()\n//\n//\t\t// Expose metrics and custom registry via an HTTP server\n//\t\t// using the HandleFor function. \"/metrics\" is the usual endpoint for that.\n//\t\thttp.Handle(\"/metrics\", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))\n//\t\tlog.Fatal(http.ListenAndServe(\":8080\", nil))\n//\t}\n//\n// This is a complete program that exports two metrics, a Gauge and a Counter,\n// the latter with a label attached to turn it into a (one-dimensional) vector.\n// It register the metrics using a custom registry and exposes them via an HTTP server\n// on the /metrics endpoint.\n//\n// # Metrics\n//\n// The number of exported identifiers in this package might appear a bit\n// overwhelming. However, in addition to the basic plumbing shown in the example\n// above, you only need to understand the different metric types and their\n// vector versions for basic usage. Furthermore, if you are not concerned with\n// fine-grained control of when and how to register metrics with the registry,\n// have a look at the promauto package, which will effectively allow you to\n// ignore registration altogether in simple cases.\n//\n// Above, you have already touched the Counter and the Gauge. There are two more\n// advanced metric types: the Summary and Histogram. A more thorough description\n// of those four metric types can be found in the Prometheus docs:\n// https://prometheus.io/docs/concepts/metric_types/\n//\n// In addition to the fundamental metric types Gauge, Counter, Summary, and\n// Histogram, a very important part of the Prometheus data model is the\n// partitioning of samples along dimensions called labels, which results in\n// metric vectors. The fundamental types are GaugeVec, CounterVec, SummaryVec,\n// and HistogramVec.\n//\n// While only the fundamental metric types implement the Metric interface, both\n// the metrics and their vector versions implement the Collector interface. A\n// Collector manages the collection of a number of Metrics, but for convenience,\n// a Metric can also “collect itself”. Note that Gauge, Counter, Summary, and\n// Histogram are interfaces themselves while GaugeVec, CounterVec, SummaryVec,\n// and HistogramVec are not.\n//\n// To create instances of Metrics and their vector versions, you need a suitable\n// …Opts struct, i.e. GaugeOpts, CounterOpts, SummaryOpts, or HistogramOpts.\n//\n// # Custom Collectors and constant Metrics\n//\n// While you could create your own implementations of Metric, most likely you\n// will only ever implement the Collector interface on your own. At a first\n// glance, a custom Collector seems handy to bundle Metrics for common\n// registration (with the prime example of the different metric vectors above,\n// which bundle all the metrics of the same name but with different labels).\n//\n// There is a more involved use case, too: If you already have metrics\n// available, created outside of the Prometheus context, you don't need the\n// interface of the various Metric types. You essentially want to mirror the\n// existing numbers into Prometheus Metrics during collection. An own\n// implementation of the Collector interface is perfect for that. You can create\n// Metric instances “on the fly” using NewConstMetric, NewConstHistogram, and\n// NewConstSummary (and their respective Must… versions). NewConstMetric is used\n// for all metric types with just a float64 as their value: Counter, Gauge, and\n// a special “type” called Untyped. Use the latter if you are not sure if the\n// mirrored metric is a Counter or a Gauge. Creation of the Metric instance\n// happens in the Collect method. The Describe method has to return separate\n// Desc instances, representative of the “throw-away” metrics to be created\n// later. NewDesc comes in handy to create those Desc instances. Alternatively,\n// you could return no Desc at all, which will mark the Collector “unchecked”.\n// No checks are performed at registration time, but metric consistency will\n// still be ensured at scrape time, i.e. any inconsistencies will lead to scrape\n// errors. Thus, with unchecked Collectors, the responsibility to not collect\n// metrics that lead to inconsistencies in the total scrape result lies with the\n// implementer of the Collector. While this is not a desirable state, it is\n// sometimes necessary. The typical use case is a situation where the exact\n// metrics to be returned by a Collector cannot be predicted at registration\n// time, but the implementer has sufficient knowledge of the whole system to\n// guarantee metric consistency.\n//\n// The Collector example illustrates the use case. You can also look at the\n// source code of the processCollector (mirroring process metrics), the\n// goCollector (mirroring Go metrics), or the expvarCollector (mirroring expvar\n// metrics) as examples that are used in this package itself.\n//\n// If you just need to call a function to get a single float value to collect as\n// a metric, GaugeFunc, CounterFunc, or UntypedFunc might be interesting\n// shortcuts.\n//\n// # Advanced Uses of the Registry\n//\n// While MustRegister is the by far most common way of registering a Collector,\n// sometimes you might want to handle the errors the registration might cause.\n// As suggested by the name, MustRegister panics if an error occurs. With the\n// Register function, the error is returned and can be handled.\n//\n// An error is returned if the registered Collector is incompatible or\n// inconsistent with already registered metrics. The registry aims for\n// consistency of the collected metrics according to the Prometheus data model.\n// Inconsistencies are ideally detected at registration time, not at collect\n// time. The former will usually be detected at start-up time of a program,\n// while the latter will only happen at scrape time, possibly not even on the\n// first scrape if the inconsistency only becomes relevant later. That is the\n// main reason why a Collector and a Metric have to describe themselves to the\n// registry.\n//\n// So far, everything we did operated on the so-called default registry, as it\n// can be found in the global DefaultRegisterer variable. With NewRegistry, you\n// can create a custom registry, or you can even implement the Registerer or\n// Gatherer interfaces yourself. The methods Register and Unregister work in the\n// same way on a custom registry as the global functions Register and Unregister\n// on the default registry.\n//\n// There are a number of uses for custom registries: You can use registries with\n// special properties, see NewPedanticRegistry. You can avoid global state, as\n// it is imposed by the DefaultRegisterer. You can use multiple registries at\n// the same time to expose different metrics in different ways. You can use\n// separate registries for testing purposes.\n//\n// Also note that the DefaultRegisterer comes registered with a Collector for Go\n// runtime metrics (via NewGoCollector) and a Collector for process metrics (via\n// NewProcessCollector). With a custom registry, you are in control and decide\n// yourself about the Collectors to register.\n//\n// # HTTP Exposition\n//\n// The Registry implements the Gatherer interface. The caller of the Gather\n// method can then expose the gathered metrics in some way. Usually, the metrics\n// are served via HTTP on the /metrics endpoint. That's happening in the example\n// above. The tools to expose metrics via HTTP are in the promhttp sub-package.\n//\n// # Pushing to the Pushgateway\n//\n// Function for pushing to the Pushgateway can be found in the push sub-package.\n//\n// # Graphite Bridge\n//\n// Functions and examples to push metrics from a Gatherer to Graphite can be\n// found in the graphite sub-package.\n//\n// # Other Means of Exposition\n//\n// More ways of exposing metrics can easily be added by following the approaches\n// of the existing implementations.\npackage prometheus\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"encoding/json\"\n\t\"expvar\"\n)\n\ntype expvarCollector struct {\n\texports map[string]*Desc\n}\n\n// NewExpvarCollector is the obsolete version of collectors.NewExpvarCollector.\n// See there for documentation.\n//\n// Deprecated: Use collectors.NewExpvarCollector instead.\nfunc NewExpvarCollector(exports map[string]*Desc) Collector {\n\treturn &expvarCollector{\n\t\texports: exports,\n\t}\n}\n\n// Describe implements Collector.\nfunc (e *expvarCollector) Describe(ch chan<- *Desc) {\n\tfor _, desc := range e.exports {\n\t\tch <- desc\n\t}\n}\n\n// Collect implements Collector.\nfunc (e *expvarCollector) Collect(ch chan<- Metric) {\n\tfor name, desc := range e.exports {\n\t\tvar m Metric\n\t\texpVar := expvar.Get(name)\n\t\tif expVar == nil {\n\t\t\tcontinue\n\t\t}\n\t\tvar v interface{}\n\t\tlabels := make([]string, len(desc.variableLabels))\n\t\tif err := json.Unmarshal([]byte(expVar.String()), &v); err != nil {\n\t\t\tch <- NewInvalidMetric(desc, err)\n\t\t\tcontinue\n\t\t}\n\t\tvar processValue func(v interface{}, i int)\n\t\tprocessValue = func(v interface{}, i int) {\n\t\t\tif i >= len(labels) {\n\t\t\t\tcopiedLabels := append(make([]string, 0, len(labels)), labels...)\n\t\t\t\tswitch v := v.(type) {\n\t\t\t\tcase float64:\n\t\t\t\t\tm = MustNewConstMetric(desc, UntypedValue, v, copiedLabels...)\n\t\t\t\tcase bool:\n\t\t\t\t\tif v {\n\t\t\t\t\t\tm = MustNewConstMetric(desc, UntypedValue, 1, copiedLabels...)\n\t\t\t\t\t} else {\n\t\t\t\t\t\tm = MustNewConstMetric(desc, UntypedValue, 0, copiedLabels...)\n\t\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tch <- m\n\t\t\t\treturn\n\t\t\t}\n\t\t\tvm, ok := v.(map[string]interface{})\n\t\t\tif !ok {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tfor lv, val := range vm {\n\t\t\t\tlabels[i] = lv\n\t\t\t\tprocessValue(val, i+1)\n\t\t\t}\n\t\t}\n\t\tprocessValue(v, 0)\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/fnv.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\n// Inline and byte-free variant of hash/fnv's fnv64a.\n\nconst (\n\toffset64 = 14695981039346656037\n\tprime64 = 1099511628211\n)\n\n// hashNew initializies a new fnv64a hash value.\nfunc hashNew() uint64 {\n\treturn offset64\n}\n\n// hashAdd adds a string to a fnv64a hash value, returning the updated hash.\nfunc hashAdd(h uint64, s string) uint64 {\n\tfor i := 0; i < len(s); i++ {\n\t\th ^= uint64(s[i])\n\t\th *= prime64\n\t}\n\treturn h\n}\n\n// hashAddByte adds a byte to a fnv64a hash value, returning the updated hash.\nfunc hashAddByte(h uint64, b byte) uint64 {\n\th ^= uint64(b)\n\th *= prime64\n\treturn h\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/gauge.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"math\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// Gauge is a Metric that represents a single numerical value that can\n// arbitrarily go up and down.\n//\n// A Gauge is typically used for measured values like temperatures or current\n// memory usage, but also \"counts\" that can go up and down, like the number of\n// running goroutines.\n//\n// To create Gauge instances, use NewGauge.\ntype Gauge interface {\n\tMetric\n\tCollector\n\n\t// Set sets the Gauge to an arbitrary value.\n\tSet(float64)\n\t// Inc increments the Gauge by 1. Use Add to increment it by arbitrary\n\t// values.\n\tInc()\n\t// Dec decrements the Gauge by 1. Use Sub to decrement it by arbitrary\n\t// values.\n\tDec()\n\t// Add adds the given value to the Gauge. (The value can be negative,\n\t// resulting in a decrease of the Gauge.)\n\tAdd(float64)\n\t// Sub subtracts the given value from the Gauge. (The value can be\n\t// negative, resulting in an increase of the Gauge.)\n\tSub(float64)\n\n\t// SetToCurrentTime sets the Gauge to the current Unix time in seconds.\n\tSetToCurrentTime()\n}\n\n// GaugeOpts is an alias for Opts. See there for doc comments.\ntype GaugeOpts Opts\n\n// NewGauge creates a new Gauge based on the provided GaugeOpts.\n//\n// The returned implementation is optimized for a fast Set method. If you have a\n// choice for managing the value of a Gauge via Set vs. Inc/Dec/Add/Sub, pick\n// the former. For example, the Inc method of the returned Gauge is slower than\n// the Inc method of a Counter returned by NewCounter. This matches the typical\n// scenarios for Gauges and Counters, where the former tends to be Set-heavy and\n// the latter Inc-heavy.\nfunc NewGauge(opts GaugeOpts) Gauge {\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tnil,\n\t\topts.ConstLabels,\n\t)\n\tresult := &gauge{desc: desc, labelPairs: desc.constLabelPairs}\n\tresult.init(result) // Init self-collection.\n\treturn result\n}\n\ntype gauge struct {\n\t// valBits contains the bits of the represented float64 value. It has\n\t// to go first in the struct to guarantee alignment for atomic\n\t// operations. http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\tvalBits uint64\n\n\tselfCollector\n\n\tdesc *Desc\n\tlabelPairs []*dto.LabelPair\n}\n\nfunc (g *gauge) Desc() *Desc {\n\treturn g.desc\n}\n\nfunc (g *gauge) Set(val float64) {\n\tatomic.StoreUint64(&g.valBits, math.Float64bits(val))\n}\n\nfunc (g *gauge) SetToCurrentTime() {\n\tg.Set(float64(time.Now().UnixNano()) / 1e9)\n}\n\nfunc (g *gauge) Inc() {\n\tg.Add(1)\n}\n\nfunc (g *gauge) Dec() {\n\tg.Add(-1)\n}\n\nfunc (g *gauge) Add(val float64) {\n\tfor {\n\t\toldBits := atomic.LoadUint64(&g.valBits)\n\t\tnewBits := math.Float64bits(math.Float64frombits(oldBits) + val)\n\t\tif atomic.CompareAndSwapUint64(&g.valBits, oldBits, newBits) {\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc (g *gauge) Sub(val float64) {\n\tg.Add(val * -1)\n}\n\nfunc (g *gauge) Write(out *dto.Metric) error {\n\tval := math.Float64frombits(atomic.LoadUint64(&g.valBits))\n\treturn populateMetric(GaugeValue, val, g.labelPairs, nil, out)\n}\n\n// GaugeVec is a Collector that bundles a set of Gauges that all share the same\n// Desc, but have different values for their variable labels. This is used if\n// you want to count the same thing partitioned by various dimensions\n// (e.g. number of operations queued, partitioned by user and operation\n// type). Create instances with NewGaugeVec.\ntype GaugeVec struct {\n\t*MetricVec\n}\n\n// NewGaugeVec creates a new GaugeVec based on the provided GaugeOpts and\n// partitioned by the given label names.\nfunc NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec {\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tlabelNames,\n\t\topts.ConstLabels,\n\t)\n\treturn &GaugeVec{\n\t\tMetricVec: NewMetricVec(desc, func(lvs ...string) Metric {\n\t\t\tif len(lvs) != len(desc.variableLabels) {\n\t\t\t\tpanic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, lvs))\n\t\t\t}\n\t\t\tresult := &gauge{desc: desc, labelPairs: MakeLabelPairs(desc, lvs)}\n\t\t\tresult.init(result) // Init self-collection.\n\t\t\treturn result\n\t\t}),\n\t}\n}\n\n// GetMetricWithLabelValues returns the Gauge for the given slice of label\n// values (same order as the variable labels in Desc). If that combination of\n// label values is accessed for the first time, a new Gauge is created.\n//\n// It is possible to call this method without using the returned Gauge to only\n// create the new Gauge but leave it at its starting value 0. See also the\n// SummaryVec example.\n//\n// Keeping the Gauge for later use is possible (and should be considered if\n// performance is critical), but keep in mind that Reset, DeleteLabelValues and\n// Delete can be used to delete the Gauge from the GaugeVec. In that case, the\n// Gauge will still exist, but it will not be exported anymore, even if a\n// Gauge with the same label values is created later. See also the CounterVec\n// example.\n//\n// An error is returned if the number of label values is not the same as the\n// number of variable labels in Desc (minus any curried labels).\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as\n// an alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\nfunc (v *GaugeVec) GetMetricWithLabelValues(lvs ...string) (Gauge, error) {\n\tmetric, err := v.MetricVec.GetMetricWithLabelValues(lvs...)\n\tif metric != nil {\n\t\treturn metric.(Gauge), err\n\t}\n\treturn nil, err\n}\n\n// GetMetricWith returns the Gauge for the given Labels map (the label names\n// must match those of the variable labels in Desc). If that label map is\n// accessed for the first time, a new Gauge is created. Implications of\n// creating a Gauge without using it and keeping the Gauge for later use are\n// the same as for GetMetricWithLabelValues.\n//\n// An error is returned if the number and names of the Labels are inconsistent\n// with those of the variable labels in Desc (minus any curried labels).\n//\n// This method is used for the same purpose as\n// GetMetricWithLabelValues(...string). See there for pros and cons of the two\n// methods.\nfunc (v *GaugeVec) GetMetricWith(labels Labels) (Gauge, error) {\n\tmetric, err := v.MetricVec.GetMetricWith(labels)\n\tif metric != nil {\n\t\treturn metric.(Gauge), err\n\t}\n\treturn nil, err\n}\n\n// WithLabelValues works as GetMetricWithLabelValues, but panics where\n// GetMetricWithLabelValues would have returned an error. Not returning an\n// error allows shortcuts like\n//\n//\tmyVec.WithLabelValues(\"404\", \"GET\").Add(42)\nfunc (v *GaugeVec) WithLabelValues(lvs ...string) Gauge {\n\tg, err := v.GetMetricWithLabelValues(lvs...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn g\n}\n\n// With works as GetMetricWith, but panics where GetMetricWithLabels would have\n// returned an error. Not returning an error allows shortcuts like\n//\n//\tmyVec.With(prometheus.Labels{\"code\": \"404\", \"method\": \"GET\"}).Add(42)\nfunc (v *GaugeVec) With(labels Labels) Gauge {\n\tg, err := v.GetMetricWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn g\n}\n\n// CurryWith returns a vector curried with the provided labels, i.e. the\n// returned vector has those labels pre-set for all labeled operations performed\n// on it. The cardinality of the curried vector is reduced accordingly. The\n// order of the remaining labels stays the same (just with the curried labels\n// taken out of the sequence – which is relevant for the\n// (GetMetric)WithLabelValues methods). It is possible to curry a curried\n// vector, but only with labels not yet used for currying before.\n//\n// The metrics contained in the GaugeVec are shared between the curried and\n// uncurried vectors. They are just accessed differently. Curried and uncurried\n// vectors behave identically in terms of collection. Only one must be\n// registered with a given registry (usually the uncurried version). The Reset\n// method deletes all metrics, even if called on a curried vector.\nfunc (v *GaugeVec) CurryWith(labels Labels) (*GaugeVec, error) {\n\tvec, err := v.MetricVec.CurryWith(labels)\n\tif vec != nil {\n\t\treturn &GaugeVec{vec}, err\n\t}\n\treturn nil, err\n}\n\n// MustCurryWith works as CurryWith but panics where CurryWith would have\n// returned an error.\nfunc (v *GaugeVec) MustCurryWith(labels Labels) *GaugeVec {\n\tvec, err := v.CurryWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn vec\n}\n\n// GaugeFunc is a Gauge whose value is determined at collect time by calling a\n// provided function.\n//\n// To create GaugeFunc instances, use NewGaugeFunc.\ntype GaugeFunc interface {\n\tMetric\n\tCollector\n}\n\n// NewGaugeFunc creates a new GaugeFunc based on the provided GaugeOpts. The\n// value reported is determined by calling the given function from within the\n// Write method. Take into account that metric collection may happen\n// concurrently. Therefore, it must be safe to call the provided function\n// concurrently.\n//\n// NewGaugeFunc is a good way to create an “info” style metric with a constant\n// value of 1. Example:\n// https://github.com/prometheus/common/blob/8558a5b7db3c84fa38b4766966059a7bd5bfa2ee/version/info.go#L36-L56\nfunc NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc {\n\treturn newValueFunc(NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tnil,\n\t\topts.ConstLabels,\n\t), GaugeValue, function)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/get_pid.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !js || wasm\n// +build !js wasm\n\npackage prometheus\n\nimport \"os\"\n\nfunc getPIDFn() func() (int, error) {\n\tpid := os.Getpid()\n\treturn func() (int, error) {\n\t\treturn pid, nil\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/get_pid_gopherjs.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build js && !wasm\n// +build js,!wasm\n\npackage prometheus\n\nfunc getPIDFn() func() (int, error) {\n\treturn func() (int, error) {\n\t\treturn 1, nil\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/go_collector.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"runtime\"\n\t\"runtime/debug\"\n\t\"time\"\n)\n\n// goRuntimeMemStats provides the metrics initially provided by runtime.ReadMemStats.\n// From Go 1.17 those similar (and better) statistics are provided by runtime/metrics, so\n// while eval closure works on runtime.MemStats, the struct from Go 1.17+ is\n// populated using runtime/metrics.\nfunc goRuntimeMemStats() memStatsMetrics {\n\treturn memStatsMetrics{\n\t\t{\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"alloc_bytes\"),\n\t\t\t\t\"Number of bytes allocated and still in use.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.Alloc) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"alloc_bytes_total\"),\n\t\t\t\t\"Total number of bytes allocated, even if freed.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.TotalAlloc) },\n\t\t\tvalType: CounterValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"sys_bytes\"),\n\t\t\t\t\"Number of bytes obtained from system.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.Sys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"lookups_total\"),\n\t\t\t\t\"Total number of pointer lookups.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.Lookups) },\n\t\t\tvalType: CounterValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"mallocs_total\"),\n\t\t\t\t\"Total number of mallocs.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.Mallocs) },\n\t\t\tvalType: CounterValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"frees_total\"),\n\t\t\t\t\"Total number of frees.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.Frees) },\n\t\t\tvalType: CounterValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_alloc_bytes\"),\n\t\t\t\t\"Number of heap bytes allocated and still in use.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapAlloc) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_sys_bytes\"),\n\t\t\t\t\"Number of heap bytes obtained from system.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_idle_bytes\"),\n\t\t\t\t\"Number of heap bytes waiting to be used.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapIdle) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_inuse_bytes\"),\n\t\t\t\t\"Number of heap bytes that are in use.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapInuse) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_released_bytes\"),\n\t\t\t\t\"Number of heap bytes released to OS.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapReleased) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"heap_objects\"),\n\t\t\t\t\"Number of allocated objects.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapObjects) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"stack_inuse_bytes\"),\n\t\t\t\t\"Number of bytes in use by the stack allocator.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.StackInuse) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"stack_sys_bytes\"),\n\t\t\t\t\"Number of bytes obtained from system for stack allocator.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.StackSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"mspan_inuse_bytes\"),\n\t\t\t\t\"Number of bytes in use by mspan structures.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.MSpanInuse) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"mspan_sys_bytes\"),\n\t\t\t\t\"Number of bytes used for mspan structures obtained from system.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.MSpanSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"mcache_inuse_bytes\"),\n\t\t\t\t\"Number of bytes in use by mcache structures.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.MCacheInuse) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"mcache_sys_bytes\"),\n\t\t\t\t\"Number of bytes used for mcache structures obtained from system.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.MCacheSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"buck_hash_sys_bytes\"),\n\t\t\t\t\"Number of bytes used by the profiling bucket hash table.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.BuckHashSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"gc_sys_bytes\"),\n\t\t\t\t\"Number of bytes used for garbage collection system metadata.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.GCSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"other_sys_bytes\"),\n\t\t\t\t\"Number of bytes used for other system allocations.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.OtherSys) },\n\t\t\tvalType: GaugeValue,\n\t\t}, {\n\t\t\tdesc: NewDesc(\n\t\t\t\tmemstatNamespace(\"next_gc_bytes\"),\n\t\t\t\t\"Number of heap bytes when next garbage collection will take place.\",\n\t\t\t\tnil, nil,\n\t\t\t),\n\t\t\teval: func(ms *runtime.MemStats) float64 { return float64(ms.NextGC) },\n\t\t\tvalType: GaugeValue,\n\t\t},\n\t}\n}\n\ntype baseGoCollector struct {\n\tgoroutinesDesc *Desc\n\tthreadsDesc *Desc\n\tgcDesc *Desc\n\tgcLastTimeDesc *Desc\n\tgoInfoDesc *Desc\n}\n\nfunc newBaseGoCollector() baseGoCollector {\n\treturn baseGoCollector{\n\t\tgoroutinesDesc: NewDesc(\n\t\t\t\"go_goroutines\",\n\t\t\t\"Number of goroutines that currently exist.\",\n\t\t\tnil, nil),\n\t\tthreadsDesc: NewDesc(\n\t\t\t\"go_threads\",\n\t\t\t\"Number of OS threads created.\",\n\t\t\tnil, nil),\n\t\tgcDesc: NewDesc(\n\t\t\t\"go_gc_duration_seconds\",\n\t\t\t\"A summary of the pause duration of garbage collection cycles.\",\n\t\t\tnil, nil),\n\t\tgcLastTimeDesc: NewDesc(\n\t\t\t\"go_memstats_last_gc_time_seconds\",\n\t\t\t\"Number of seconds since 1970 of last garbage collection.\",\n\t\t\tnil, nil),\n\t\tgoInfoDesc: NewDesc(\n\t\t\t\"go_info\",\n\t\t\t\"Information about the Go environment.\",\n\t\t\tnil, Labels{\"version\": runtime.Version()}),\n\t}\n}\n\n// Describe returns all descriptions of the collector.\nfunc (c *baseGoCollector) Describe(ch chan<- *Desc) {\n\tch <- c.goroutinesDesc\n\tch <- c.threadsDesc\n\tch <- c.gcDesc\n\tch <- c.gcLastTimeDesc\n\tch <- c.goInfoDesc\n}\n\n// Collect returns the current state of all metrics of the collector.\nfunc (c *baseGoCollector) Collect(ch chan<- Metric) {\n\tch <- MustNewConstMetric(c.goroutinesDesc, GaugeValue, float64(runtime.NumGoroutine()))\n\n\tn := getRuntimeNumThreads()\n\tch <- MustNewConstMetric(c.threadsDesc, GaugeValue, n)\n\n\tvar stats debug.GCStats\n\tstats.PauseQuantiles = make([]time.Duration, 5)\n\tdebug.ReadGCStats(&stats)\n\n\tquantiles := make(map[float64]float64)\n\tfor idx, pq := range stats.PauseQuantiles[1:] {\n\t\tquantiles[float64(idx+1)/float64(len(stats.PauseQuantiles)-1)] = pq.Seconds()\n\t}\n\tquantiles[0.0] = stats.PauseQuantiles[0].Seconds()\n\tch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), stats.PauseTotal.Seconds(), quantiles)\n\tch <- MustNewConstMetric(c.gcLastTimeDesc, GaugeValue, float64(stats.LastGC.UnixNano())/1e9)\n\tch <- MustNewConstMetric(c.goInfoDesc, GaugeValue, 1)\n}\n\nfunc memstatNamespace(s string) string {\n\treturn \"go_memstats_\" + s\n}\n\n// memStatsMetrics provide description, evaluator, runtime/metrics name, and\n// value type for memstat metrics.\ntype memStatsMetrics []struct {\n\tdesc *Desc\n\teval func(*runtime.MemStats) float64\n\tvalType ValueType\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !go1.17\n// +build !go1.17\n\npackage prometheus\n\nimport (\n\t\"runtime\"\n\t\"sync\"\n\t\"time\"\n)\n\ntype goCollector struct {\n\tbase baseGoCollector\n\n\t// ms... are memstats related.\n\tmsLast *runtime.MemStats // Previously collected memstats.\n\tmsLastTimestamp time.Time\n\tmsMtx sync.Mutex // Protects msLast and msLastTimestamp.\n\tmsMetrics memStatsMetrics\n\tmsRead func(*runtime.MemStats) // For mocking in tests.\n\tmsMaxWait time.Duration // Wait time for fresh memstats.\n\tmsMaxAge time.Duration // Maximum allowed age of old memstats.\n}\n\n// NewGoCollector is the obsolete version of collectors.NewGoCollector.\n// See there for documentation.\n//\n// Deprecated: Use collectors.NewGoCollector instead.\nfunc NewGoCollector() Collector {\n\tmsMetrics := goRuntimeMemStats()\n\tmsMetrics = append(msMetrics, struct {\n\t\tdesc *Desc\n\t\teval func(*runtime.MemStats) float64\n\t\tvalType ValueType\n\t}{\n\t\t// This metric is omitted in Go1.17+, see https://github.com/prometheus/client_golang/issues/842#issuecomment-861812034\n\t\tdesc: NewDesc(\n\t\t\tmemstatNamespace(\"gc_cpu_fraction\"),\n\t\t\t\"The fraction of this program's available CPU time used by the GC since the program started.\",\n\t\t\tnil, nil,\n\t\t),\n\t\teval: func(ms *runtime.MemStats) float64 { return ms.GCCPUFraction },\n\t\tvalType: GaugeValue,\n\t})\n\treturn &goCollector{\n\t\tbase: newBaseGoCollector(),\n\t\tmsLast: &runtime.MemStats{},\n\t\tmsRead: runtime.ReadMemStats,\n\t\tmsMaxWait: time.Second,\n\t\tmsMaxAge: 5 * time.Minute,\n\t\tmsMetrics: msMetrics,\n\t}\n}\n\n// Describe returns all descriptions of the collector.\nfunc (c *goCollector) Describe(ch chan<- *Desc) {\n\tc.base.Describe(ch)\n\tfor _, i := range c.msMetrics {\n\t\tch <- i.desc\n\t}\n}\n\n// Collect returns the current state of all metrics of the collector.\nfunc (c *goCollector) Collect(ch chan<- Metric) {\n\tvar (\n\t\tms = &runtime.MemStats{}\n\t\tdone = make(chan struct{})\n\t)\n\t// Start reading memstats first as it might take a while.\n\tgo func() {\n\t\tc.msRead(ms)\n\t\tc.msMtx.Lock()\n\t\tc.msLast = ms\n\t\tc.msLastTimestamp = time.Now()\n\t\tc.msMtx.Unlock()\n\t\tclose(done)\n\t}()\n\n\t// Collect base non-memory metrics.\n\tc.base.Collect(ch)\n\n\ttimer := time.NewTimer(c.msMaxWait)\n\tselect {\n\tcase <-done: // Our own ReadMemStats succeeded in time. Use it.\n\t\ttimer.Stop() // Important for high collection frequencies to not pile up timers.\n\t\tc.msCollect(ch, ms)\n\t\treturn\n\tcase <-timer.C: // Time out, use last memstats if possible. Continue below.\n\t}\n\tc.msMtx.Lock()\n\tif time.Since(c.msLastTimestamp) < c.msMaxAge {\n\t\t// Last memstats are recent enough. Collect from them under the lock.\n\t\tc.msCollect(ch, c.msLast)\n\t\tc.msMtx.Unlock()\n\t\treturn\n\t}\n\t// If we are here, the last memstats are too old or don't exist. We have\n\t// to wait until our own ReadMemStats finally completes. For that to\n\t// happen, we have to release the lock.\n\tc.msMtx.Unlock()\n\t<-done\n\tc.msCollect(ch, ms)\n}\n\nfunc (c *goCollector) msCollect(ch chan<- Metric, ms *runtime.MemStats) {\n\tfor _, i := range c.msMetrics {\n\t\tch <- MustNewConstMetric(i.desc, i.valType, i.eval(ms))\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build go1.17\n// +build go1.17\n\npackage prometheus\n\nimport (\n\t\"math\"\n\t\"runtime\"\n\t\"runtime/metrics\"\n\t\"strings\"\n\t\"sync\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/prometheus/client_golang/prometheus/internal\"\n)\n\nconst (\n\t// constants for strings referenced more than once.\n\tgoGCHeapTinyAllocsObjects = \"/gc/heap/tiny/allocs:objects\"\n\tgoGCHeapAllocsObjects = \"/gc/heap/allocs:objects\"\n\tgoGCHeapFreesObjects = \"/gc/heap/frees:objects\"\n\tgoGCHeapFreesBytes = \"/gc/heap/frees:bytes\"\n\tgoGCHeapAllocsBytes = \"/gc/heap/allocs:bytes\"\n\tgoGCHeapObjects = \"/gc/heap/objects:objects\"\n\tgoGCHeapGoalBytes = \"/gc/heap/goal:bytes\"\n\tgoMemoryClassesTotalBytes = \"/memory/classes/total:bytes\"\n\tgoMemoryClassesHeapObjectsBytes = \"/memory/classes/heap/objects:bytes\"\n\tgoMemoryClassesHeapUnusedBytes = \"/memory/classes/heap/unused:bytes\"\n\tgoMemoryClassesHeapReleasedBytes = \"/memory/classes/heap/released:bytes\"\n\tgoMemoryClassesHeapFreeBytes = \"/memory/classes/heap/free:bytes\"\n\tgoMemoryClassesHeapStacksBytes = \"/memory/classes/heap/stacks:bytes\"\n\tgoMemoryClassesOSStacksBytes = \"/memory/classes/os-stacks:bytes\"\n\tgoMemoryClassesMetadataMSpanInuseBytes = \"/memory/classes/metadata/mspan/inuse:bytes\"\n\tgoMemoryClassesMetadataMSPanFreeBytes = \"/memory/classes/metadata/mspan/free:bytes\"\n\tgoMemoryClassesMetadataMCacheInuseBytes = \"/memory/classes/metadata/mcache/inuse:bytes\"\n\tgoMemoryClassesMetadataMCacheFreeBytes = \"/memory/classes/metadata/mcache/free:bytes\"\n\tgoMemoryClassesProfilingBucketsBytes = \"/memory/classes/profiling/buckets:bytes\"\n\tgoMemoryClassesMetadataOtherBytes = \"/memory/classes/metadata/other:bytes\"\n\tgoMemoryClassesOtherBytes = \"/memory/classes/other:bytes\"\n)\n\n// rmNamesForMemStatsMetrics represents runtime/metrics names required to populate goRuntimeMemStats from like logic.\nvar rmNamesForMemStatsMetrics = []string{\n\tgoGCHeapTinyAllocsObjects,\n\tgoGCHeapAllocsObjects,\n\tgoGCHeapFreesObjects,\n\tgoGCHeapAllocsBytes,\n\tgoGCHeapObjects,\n\tgoGCHeapGoalBytes,\n\tgoMemoryClassesTotalBytes,\n\tgoMemoryClassesHeapObjectsBytes,\n\tgoMemoryClassesHeapUnusedBytes,\n\tgoMemoryClassesHeapReleasedBytes,\n\tgoMemoryClassesHeapFreeBytes,\n\tgoMemoryClassesHeapStacksBytes,\n\tgoMemoryClassesOSStacksBytes,\n\tgoMemoryClassesMetadataMSpanInuseBytes,\n\tgoMemoryClassesMetadataMSPanFreeBytes,\n\tgoMemoryClassesMetadataMCacheInuseBytes,\n\tgoMemoryClassesMetadataMCacheFreeBytes,\n\tgoMemoryClassesProfilingBucketsBytes,\n\tgoMemoryClassesMetadataOtherBytes,\n\tgoMemoryClassesOtherBytes,\n}\n\nfunc bestEffortLookupRM(lookup []string) []metrics.Description {\n\tret := make([]metrics.Description, 0, len(lookup))\n\tfor _, rm := range metrics.All() {\n\t\tfor _, m := range lookup {\n\t\t\tif m == rm.Name {\n\t\t\t\tret = append(ret, rm)\n\t\t\t}\n\t\t}\n\t}\n\treturn ret\n}\n\ntype goCollector struct {\n\tbase baseGoCollector\n\n\t// mu protects updates to all fields ensuring a consistent\n\t// snapshot is always produced by Collect.\n\tmu sync.Mutex\n\n\t// Contains all samples that has to retrieved from runtime/metrics (not all of them will be exposed).\n\tsampleBuf []metrics.Sample\n\t// sampleMap allows lookup for MemStats metrics and runtime/metrics histograms for exact sums.\n\tsampleMap map[string]*metrics.Sample\n\n\t// rmExposedMetrics represents all runtime/metrics package metrics\n\t// that were configured to be exposed.\n\trmExposedMetrics []collectorMetric\n\trmExactSumMapForHist map[string]string\n\n\t// With Go 1.17, the runtime/metrics package was introduced.\n\t// From that point on, metric names produced by the runtime/metrics\n\t// package could be generated from runtime/metrics names. However,\n\t// these differ from the old names for the same values.\n\t//\n\t// This field exists to export the same values under the old names\n\t// as well.\n\tmsMetrics memStatsMetrics\n\tmsMetricsEnabled bool\n}\n\ntype rmMetricDesc struct {\n\tmetrics.Description\n}\n\nfunc matchRuntimeMetricsRules(rules []internal.GoCollectorRule) []rmMetricDesc {\n\tvar descs []rmMetricDesc\n\tfor _, d := range metrics.All() {\n\t\tvar (\n\t\t\tdeny = true\n\t\t\tdesc rmMetricDesc\n\t\t)\n\n\t\tfor _, r := range rules {\n\t\t\tif !r.Matcher.MatchString(d.Name) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tdeny = r.Deny\n\t\t}\n\t\tif deny {\n\t\t\tcontinue\n\t\t}\n\n\t\tdesc.Description = d\n\t\tdescs = append(descs, desc)\n\t}\n\treturn descs\n}\n\nfunc defaultGoCollectorOptions() internal.GoCollectorOptions {\n\treturn internal.GoCollectorOptions{\n\t\tRuntimeMetricSumForHist: map[string]string{\n\t\t\t\"/gc/heap/allocs-by-size:bytes\": goGCHeapAllocsBytes,\n\t\t\t\"/gc/heap/frees-by-size:bytes\": goGCHeapFreesBytes,\n\t\t},\n\t\tRuntimeMetricRules: []internal.GoCollectorRule{\n\t\t\t//{Matcher: regexp.MustCompile(\"\")},\n\t\t},\n\t}\n}\n\n// NewGoCollector is the obsolete version of collectors.NewGoCollector.\n// See there for documentation.\n//\n// Deprecated: Use collectors.NewGoCollector instead.\nfunc NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector {\n\topt := defaultGoCollectorOptions()\n\tfor _, o := range opts {\n\t\to(&opt)\n\t}\n\n\texposedDescriptions := matchRuntimeMetricsRules(opt.RuntimeMetricRules)\n\n\t// Collect all histogram samples so that we can get their buckets.\n\t// The API guarantees that the buckets are always fixed for the lifetime\n\t// of the process.\n\tvar histograms []metrics.Sample\n\tfor _, d := range exposedDescriptions {\n\t\tif d.Kind == metrics.KindFloat64Histogram {\n\t\t\thistograms = append(histograms, metrics.Sample{Name: d.Name})\n\t\t}\n\t}\n\n\tif len(histograms) > 0 {\n\t\tmetrics.Read(histograms)\n\t}\n\n\tbucketsMap := make(map[string][]float64)\n\tfor i := range histograms {\n\t\tbucketsMap[histograms[i].Name] = histograms[i].Value.Float64Histogram().Buckets\n\t}\n\n\t// Generate a collector for each exposed runtime/metrics metric.\n\tmetricSet := make([]collectorMetric, 0, len(exposedDescriptions))\n\t// SampleBuf is used for reading from runtime/metrics.\n\t// We are assuming the largest case to have stable pointers for sampleMap purposes.\n\tsampleBuf := make([]metrics.Sample, 0, len(exposedDescriptions)+len(opt.RuntimeMetricSumForHist)+len(rmNamesForMemStatsMetrics))\n\tsampleMap := make(map[string]*metrics.Sample, len(exposedDescriptions))\n\tfor _, d := range exposedDescriptions {\n\t\tnamespace, subsystem, name, ok := internal.RuntimeMetricsToProm(&d.Description)\n\t\tif !ok {\n\t\t\t// Just ignore this metric; we can't do anything with it here.\n\t\t\t// If a user decides to use the latest version of Go, we don't want\n\t\t\t// to fail here. This condition is tested in TestExpectedRuntimeMetrics.\n\t\t\tcontinue\n\t\t}\n\n\t\tsampleBuf = append(sampleBuf, metrics.Sample{Name: d.Name})\n\t\tsampleMap[d.Name] = &sampleBuf[len(sampleBuf)-1]\n\n\t\tvar m collectorMetric\n\t\tif d.Kind == metrics.KindFloat64Histogram {\n\t\t\t_, hasSum := opt.RuntimeMetricSumForHist[d.Name]\n\t\t\tunit := d.Name[strings.IndexRune(d.Name, ':')+1:]\n\t\t\tm = newBatchHistogram(\n\t\t\t\tNewDesc(\n\t\t\t\t\tBuildFQName(namespace, subsystem, name),\n\t\t\t\t\td.Description.Description,\n\t\t\t\t\tnil,\n\t\t\t\t\tnil,\n\t\t\t\t),\n\t\t\t\tinternal.RuntimeMetricsBucketsForUnit(bucketsMap[d.Name], unit),\n\t\t\t\thasSum,\n\t\t\t)\n\t\t} else if d.Cumulative {\n\t\t\tm = NewCounter(CounterOpts{\n\t\t\t\tNamespace: namespace,\n\t\t\t\tSubsystem: subsystem,\n\t\t\t\tName: name,\n\t\t\t\tHelp: d.Description.Description,\n\t\t\t},\n\t\t\t)\n\t\t} else {\n\t\t\tm = NewGauge(GaugeOpts{\n\t\t\t\tNamespace: namespace,\n\t\t\t\tSubsystem: subsystem,\n\t\t\t\tName: name,\n\t\t\t\tHelp: d.Description.Description,\n\t\t\t})\n\t\t}\n\t\tmetricSet = append(metricSet, m)\n\t}\n\n\t// Add exact sum metrics to sampleBuf if not added before.\n\tfor _, h := range histograms {\n\t\tsumMetric, ok := opt.RuntimeMetricSumForHist[h.Name]\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\n\t\tif _, ok := sampleMap[sumMetric]; ok {\n\t\t\tcontinue\n\t\t}\n\t\tsampleBuf = append(sampleBuf, metrics.Sample{Name: sumMetric})\n\t\tsampleMap[sumMetric] = &sampleBuf[len(sampleBuf)-1]\n\t}\n\n\tvar (\n\t\tmsMetrics memStatsMetrics\n\t\tmsDescriptions []metrics.Description\n\t)\n\n\tif !opt.DisableMemStatsLikeMetrics {\n\t\tmsMetrics = goRuntimeMemStats()\n\t\tmsDescriptions = bestEffortLookupRM(rmNamesForMemStatsMetrics)\n\n\t\t// Check if metric was not exposed before and if not, add to sampleBuf.\n\t\tfor _, mdDesc := range msDescriptions {\n\t\t\tif _, ok := sampleMap[mdDesc.Name]; ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tsampleBuf = append(sampleBuf, metrics.Sample{Name: mdDesc.Name})\n\t\t\tsampleMap[mdDesc.Name] = &sampleBuf[len(sampleBuf)-1]\n\t\t}\n\t}\n\n\treturn &goCollector{\n\t\tbase: newBaseGoCollector(),\n\t\tsampleBuf: sampleBuf,\n\t\tsampleMap: sampleMap,\n\t\trmExposedMetrics: metricSet,\n\t\trmExactSumMapForHist: opt.RuntimeMetricSumForHist,\n\t\tmsMetrics: msMetrics,\n\t\tmsMetricsEnabled: !opt.DisableMemStatsLikeMetrics,\n\t}\n}\n\n// Describe returns all descriptions of the collector.\nfunc (c *goCollector) Describe(ch chan<- *Desc) {\n\tc.base.Describe(ch)\n\tfor _, i := range c.msMetrics {\n\t\tch <- i.desc\n\t}\n\tfor _, m := range c.rmExposedMetrics {\n\t\tch <- m.Desc()\n\t}\n}\n\n// Collect returns the current state of all metrics of the collector.\nfunc (c *goCollector) Collect(ch chan<- Metric) {\n\t// Collect base non-memory metrics.\n\tc.base.Collect(ch)\n\n\tif len(c.sampleBuf) == 0 {\n\t\treturn\n\t}\n\n\t// Collect must be thread-safe, so prevent concurrent use of\n\t// sampleBuf elements. Just read into sampleBuf but write all the data\n\t// we get into our Metrics or MemStats.\n\t//\n\t// This lock also ensures that the Metrics we send out are all from\n\t// the same updates, ensuring their mutual consistency insofar as\n\t// is guaranteed by the runtime/metrics package.\n\t//\n\t// N.B. This locking is heavy-handed, but Collect is expected to be called\n\t// relatively infrequently. Also the core operation here, metrics.Read,\n\t// is fast (O(tens of microseconds)) so contention should certainly be\n\t// low, though channel operations and any allocations may add to that.\n\tc.mu.Lock()\n\tdefer c.mu.Unlock()\n\n\t// Populate runtime/metrics sample buffer.\n\tmetrics.Read(c.sampleBuf)\n\n\t// Collect all our runtime/metrics user chose to expose from sampleBuf (if any).\n\tfor i, metric := range c.rmExposedMetrics {\n\t\t// We created samples for exposed metrics first in order, so indexes match.\n\t\tsample := c.sampleBuf[i]\n\n\t\t// N.B. switch on concrete type because it's significantly more efficient\n\t\t// than checking for the Counter and Gauge interface implementations. In\n\t\t// this case, we control all the types here.\n\t\tswitch m := metric.(type) {\n\t\tcase *counter:\n\t\t\t// Guard against decreases. This should never happen, but a failure\n\t\t\t// to do so will result in a panic, which is a harsh consequence for\n\t\t\t// a metrics collection bug.\n\t\t\tv0, v1 := m.get(), unwrapScalarRMValue(sample.Value)\n\t\t\tif v1 > v0 {\n\t\t\t\tm.Add(unwrapScalarRMValue(sample.Value) - m.get())\n\t\t\t}\n\t\t\tm.Collect(ch)\n\t\tcase *gauge:\n\t\t\tm.Set(unwrapScalarRMValue(sample.Value))\n\t\t\tm.Collect(ch)\n\t\tcase *batchHistogram:\n\t\t\tm.update(sample.Value.Float64Histogram(), c.exactSumFor(sample.Name))\n\t\t\tm.Collect(ch)\n\t\tdefault:\n\t\t\tpanic(\"unexpected metric type\")\n\t\t}\n\t}\n\n\tif c.msMetricsEnabled {\n\t\t// ms is a dummy MemStats that we populate ourselves so that we can\n\t\t// populate the old metrics from it if goMemStatsCollection is enabled.\n\t\tvar ms runtime.MemStats\n\t\tmemStatsFromRM(&ms, c.sampleMap)\n\t\tfor _, i := range c.msMetrics {\n\t\t\tch <- MustNewConstMetric(i.desc, i.valType, i.eval(&ms))\n\t\t}\n\t}\n}\n\n// unwrapScalarRMValue unwraps a runtime/metrics value that is assumed\n// to be scalar and returns the equivalent float64 value. Panics if the\n// value is not scalar.\nfunc unwrapScalarRMValue(v metrics.Value) float64 {\n\tswitch v.Kind() {\n\tcase metrics.KindUint64:\n\t\treturn float64(v.Uint64())\n\tcase metrics.KindFloat64:\n\t\treturn v.Float64()\n\tcase metrics.KindBad:\n\t\t// Unsupported metric.\n\t\t//\n\t\t// This should never happen because we always populate our metric\n\t\t// set from the runtime/metrics package.\n\t\tpanic(\"unexpected unsupported metric\")\n\tdefault:\n\t\t// Unsupported metric kind.\n\t\t//\n\t\t// This should never happen because we check for this during initialization\n\t\t// and flag and filter metrics whose kinds we don't understand.\n\t\tpanic(\"unexpected unsupported metric kind\")\n\t}\n}\n\n// exactSumFor takes a runtime/metrics metric name (that is assumed to\n// be of kind KindFloat64Histogram) and returns its exact sum and whether\n// its exact sum exists.\n//\n// The runtime/metrics API for histograms doesn't currently expose exact\n// sums, but some of the other metrics are in fact exact sums of histograms.\nfunc (c *goCollector) exactSumFor(rmName string) float64 {\n\tsumName, ok := c.rmExactSumMapForHist[rmName]\n\tif !ok {\n\t\treturn 0\n\t}\n\ts, ok := c.sampleMap[sumName]\n\tif !ok {\n\t\treturn 0\n\t}\n\treturn unwrapScalarRMValue(s.Value)\n}\n\nfunc memStatsFromRM(ms *runtime.MemStats, rm map[string]*metrics.Sample) {\n\tlookupOrZero := func(name string) uint64 {\n\t\tif s, ok := rm[name]; ok {\n\t\t\treturn s.Value.Uint64()\n\t\t}\n\t\treturn 0\n\t}\n\n\t// Currently, MemStats adds tiny alloc count to both Mallocs AND Frees.\n\t// The reason for this is because MemStats couldn't be extended at the time\n\t// but there was a desire to have Mallocs at least be a little more representative,\n\t// while having Mallocs - Frees still represent a live object count.\n\t// Unfortunately, MemStats doesn't actually export a large allocation count,\n\t// so it's impossible to pull this number out directly.\n\ttinyAllocs := lookupOrZero(goGCHeapTinyAllocsObjects)\n\tms.Mallocs = lookupOrZero(goGCHeapAllocsObjects) + tinyAllocs\n\tms.Frees = lookupOrZero(goGCHeapFreesObjects) + tinyAllocs\n\n\tms.TotalAlloc = lookupOrZero(goGCHeapAllocsBytes)\n\tms.Sys = lookupOrZero(goMemoryClassesTotalBytes)\n\tms.Lookups = 0 // Already always zero.\n\tms.HeapAlloc = lookupOrZero(goMemoryClassesHeapObjectsBytes)\n\tms.Alloc = ms.HeapAlloc\n\tms.HeapInuse = ms.HeapAlloc + lookupOrZero(goMemoryClassesHeapUnusedBytes)\n\tms.HeapReleased = lookupOrZero(goMemoryClassesHeapReleasedBytes)\n\tms.HeapIdle = ms.HeapReleased + lookupOrZero(goMemoryClassesHeapFreeBytes)\n\tms.HeapSys = ms.HeapInuse + ms.HeapIdle\n\tms.HeapObjects = lookupOrZero(goGCHeapObjects)\n\tms.StackInuse = lookupOrZero(goMemoryClassesHeapStacksBytes)\n\tms.StackSys = ms.StackInuse + lookupOrZero(goMemoryClassesOSStacksBytes)\n\tms.MSpanInuse = lookupOrZero(goMemoryClassesMetadataMSpanInuseBytes)\n\tms.MSpanSys = ms.MSpanInuse + lookupOrZero(goMemoryClassesMetadataMSPanFreeBytes)\n\tms.MCacheInuse = lookupOrZero(goMemoryClassesMetadataMCacheInuseBytes)\n\tms.MCacheSys = ms.MCacheInuse + lookupOrZero(goMemoryClassesMetadataMCacheFreeBytes)\n\tms.BuckHashSys = lookupOrZero(goMemoryClassesProfilingBucketsBytes)\n\tms.GCSys = lookupOrZero(goMemoryClassesMetadataOtherBytes)\n\tms.OtherSys = lookupOrZero(goMemoryClassesOtherBytes)\n\tms.NextGC = lookupOrZero(goGCHeapGoalBytes)\n\n\t// N.B. GCCPUFraction is intentionally omitted. This metric is not useful,\n\t// and often misleading due to the fact that it's an average over the lifetime\n\t// of the process.\n\t// See https://github.com/prometheus/client_golang/issues/842#issuecomment-861812034\n\t// for more details.\n\tms.GCCPUFraction = 0\n}\n\n// batchHistogram is a mutable histogram that is updated\n// in batches.\ntype batchHistogram struct {\n\tselfCollector\n\n\t// Static fields updated only once.\n\tdesc *Desc\n\thasSum bool\n\n\t// Because this histogram operates in batches, it just uses a\n\t// single mutex for everything. updates are always serialized\n\t// but Write calls may operate concurrently with updates.\n\t// Contention between these two sources should be rare.\n\tmu sync.Mutex\n\tbuckets []float64 // Inclusive lower bounds, like runtime/metrics.\n\tcounts []uint64\n\tsum float64 // Used if hasSum is true.\n}\n\n// newBatchHistogram creates a new batch histogram value with the given\n// Desc, buckets, and whether or not it has an exact sum available.\n//\n// buckets must always be from the runtime/metrics package, following\n// the same conventions.\nfunc newBatchHistogram(desc *Desc, buckets []float64, hasSum bool) *batchHistogram {\n\t// We need to remove -Inf values. runtime/metrics keeps them around.\n\t// But -Inf bucket should not be allowed for prometheus histograms.\n\tif buckets[0] == math.Inf(-1) {\n\t\tbuckets = buckets[1:]\n\t}\n\th := &batchHistogram{\n\t\tdesc: desc,\n\t\tbuckets: buckets,\n\t\t// Because buckets follows runtime/metrics conventions, there's\n\t\t// 1 more value in the buckets list than there are buckets represented,\n\t\t// because in runtime/metrics, the bucket values represent *boundaries*,\n\t\t// and non-Inf boundaries are inclusive lower bounds for that bucket.\n\t\tcounts: make([]uint64, len(buckets)-1),\n\t\thasSum: hasSum,\n\t}\n\th.init(h)\n\treturn h\n}\n\n// update updates the batchHistogram from a runtime/metrics histogram.\n//\n// sum must be provided if the batchHistogram was created to have an exact sum.\n// h.buckets must be a strict subset of his.Buckets.\nfunc (h *batchHistogram) update(his *metrics.Float64Histogram, sum float64) {\n\tcounts, buckets := his.Counts, his.Buckets\n\n\th.mu.Lock()\n\tdefer h.mu.Unlock()\n\n\t// Clear buckets.\n\tfor i := range h.counts {\n\t\th.counts[i] = 0\n\t}\n\t// Copy and reduce buckets.\n\tvar j int\n\tfor i, count := range counts {\n\t\th.counts[j] += count\n\t\tif buckets[i+1] == h.buckets[j+1] {\n\t\t\tj++\n\t\t}\n\t}\n\tif h.hasSum {\n\t\th.sum = sum\n\t}\n}\n\nfunc (h *batchHistogram) Desc() *Desc {\n\treturn h.desc\n}\n\nfunc (h *batchHistogram) Write(out *dto.Metric) error {\n\th.mu.Lock()\n\tdefer h.mu.Unlock()\n\n\tsum := float64(0)\n\tif h.hasSum {\n\t\tsum = h.sum\n\t}\n\tdtoBuckets := make([]*dto.Bucket, 0, len(h.counts))\n\ttotalCount := uint64(0)\n\tfor i, count := range h.counts {\n\t\ttotalCount += count\n\t\tif !h.hasSum {\n\t\t\tif count != 0 {\n\t\t\t\t// N.B. This computed sum is an underestimate.\n\t\t\t\tsum += h.buckets[i] * float64(count)\n\t\t\t}\n\t\t}\n\n\t\t// Skip the +Inf bucket, but only for the bucket list.\n\t\t// It must still count for sum and totalCount.\n\t\tif math.IsInf(h.buckets[i+1], 1) {\n\t\t\tbreak\n\t\t}\n\t\t// Float64Histogram's upper bound is exclusive, so make it inclusive\n\t\t// by obtaining the next float64 value down, in order.\n\t\tupperBound := math.Nextafter(h.buckets[i+1], h.buckets[i])\n\t\tdtoBuckets = append(dtoBuckets, &dto.Bucket{\n\t\t\tCumulativeCount: proto.Uint64(totalCount),\n\t\t\tUpperBound: proto.Float64(upperBound),\n\t\t})\n\t}\n\tout.Histogram = &dto.Histogram{\n\t\tBucket: dtoBuckets,\n\t\tSampleCount: proto.Uint64(totalCount),\n\t\tSampleSum: proto.Float64(sum),\n\t}\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/histogram.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"runtime\"\n\t\"sort\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// nativeHistogramBounds for the frac of observed values. Only relevant for\n// schema > 0. The position in the slice is the schema. (0 is never used, just\n// here for convenience of using the schema directly as the index.)\n//\n// TODO(beorn7): Currently, we do a binary search into these slices. There are\n// ways to turn it into a small number of simple array lookups. It probably only\n// matters for schema 5 and beyond, but should be investigated. See this comment\n// as a starting point:\n// https://github.com/open-telemetry/opentelemetry-specification/issues/1776#issuecomment-870164310\nvar nativeHistogramBounds = [][]float64{\n\t// Schema \"0\":\n\t{0.5},\n\t// Schema 1:\n\t{0.5, 0.7071067811865475},\n\t// Schema 2:\n\t{0.5, 0.5946035575013605, 0.7071067811865475, 0.8408964152537144},\n\t// Schema 3:\n\t{\n\t\t0.5, 0.5452538663326288, 0.5946035575013605, 0.6484197773255048,\n\t\t0.7071067811865475, 0.7711054127039704, 0.8408964152537144, 0.9170040432046711,\n\t},\n\t// Schema 4:\n\t{\n\t\t0.5, 0.5221368912137069, 0.5452538663326288, 0.5693943173783458,\n\t\t0.5946035575013605, 0.620928906036742, 0.6484197773255048, 0.6771277734684463,\n\t\t0.7071067811865475, 0.7384130729697496, 0.7711054127039704, 0.805245165974627,\n\t\t0.8408964152537144, 0.8781260801866495, 0.9170040432046711, 0.9576032806985735,\n\t},\n\t// Schema 5:\n\t{\n\t\t0.5, 0.5109485743270583, 0.5221368912137069, 0.5335702003384117,\n\t\t0.5452538663326288, 0.5571933712979462, 0.5693943173783458, 0.5818624293887887,\n\t\t0.5946035575013605, 0.6076236799902344, 0.620928906036742, 0.6345254785958666,\n\t\t0.6484197773255048, 0.6626183215798706, 0.6771277734684463, 0.6919549409819159,\n\t\t0.7071067811865475, 0.7225904034885232, 0.7384130729697496, 0.7545822137967112,\n\t\t0.7711054127039704, 0.7879904225539431, 0.805245165974627, 0.8228777390769823,\n\t\t0.8408964152537144, 0.8593096490612387, 0.8781260801866495, 0.8973545375015533,\n\t\t0.9170040432046711, 0.9370838170551498, 0.9576032806985735, 0.9785720620876999,\n\t},\n\t// Schema 6:\n\t{\n\t\t0.5, 0.5054446430258502, 0.5109485743270583, 0.5165124395106142,\n\t\t0.5221368912137069, 0.5278225891802786, 0.5335702003384117, 0.5393803988785598,\n\t\t0.5452538663326288, 0.5511912916539204, 0.5571933712979462, 0.5632608093041209,\n\t\t0.5693943173783458, 0.5755946149764913, 0.5818624293887887, 0.5881984958251406,\n\t\t0.5946035575013605, 0.6010783657263515, 0.6076236799902344, 0.6142402680534349,\n\t\t0.620928906036742, 0.6276903785123455, 0.6345254785958666, 0.6414350080393891,\n\t\t0.6484197773255048, 0.6554806057623822, 0.6626183215798706, 0.6698337620266515,\n\t\t0.6771277734684463, 0.6845012114872953, 0.6919549409819159, 0.6994898362691555,\n\t\t0.7071067811865475, 0.7148066691959849, 0.7225904034885232, 0.7304588970903234,\n\t\t0.7384130729697496, 0.7464538641456323, 0.7545822137967112, 0.762799075372269,\n\t\t0.7711054127039704, 0.7795022001189185, 0.7879904225539431, 0.7965710756711334,\n\t\t0.805245165974627, 0.8140137109286738, 0.8228777390769823, 0.8318382901633681,\n\t\t0.8408964152537144, 0.8500531768592616, 0.8593096490612387, 0.8686669176368529,\n\t\t0.8781260801866495, 0.8876882462632604, 0.8973545375015533, 0.9071260877501991,\n\t\t0.9170040432046711, 0.9269895625416926, 0.9370838170551498, 0.9472879907934827,\n\t\t0.9576032806985735, 0.9680308967461471, 0.9785720620876999, 0.9892280131939752,\n\t},\n\t// Schema 7:\n\t{\n\t\t0.5, 0.5027149505564014, 0.5054446430258502, 0.5081891574554764,\n\t\t0.5109485743270583, 0.5137229745593818, 0.5165124395106142, 0.5193170509806894,\n\t\t0.5221368912137069, 0.5249720429003435, 0.5278225891802786, 0.5306886136446309,\n\t\t0.5335702003384117, 0.5364674337629877, 0.5393803988785598, 0.5423091811066545,\n\t\t0.5452538663326288, 0.5482145409081883, 0.5511912916539204, 0.5541842058618393,\n\t\t0.5571933712979462, 0.5602188762048033, 0.5632608093041209, 0.5663192597993595,\n\t\t0.5693943173783458, 0.572486072215902, 0.5755946149764913, 0.5787200368168754,\n\t\t0.5818624293887887, 0.585021884841625, 0.5881984958251406, 0.5913923554921704,\n\t\t0.5946035575013605, 0.5978321960199137, 0.6010783657263515, 0.6043421618132907,\n\t\t0.6076236799902344, 0.6109230164863786, 0.6142402680534349, 0.6175755319684665,\n\t\t0.620928906036742, 0.6243004885946023, 0.6276903785123455, 0.6310986751971253,\n\t\t0.6345254785958666, 0.637970889198196, 0.6414350080393891, 0.6449179367033329,\n\t\t0.6484197773255048, 0.6519406325959679, 0.6554806057623822, 0.659039800633032,\n\t\t0.6626183215798706, 0.6662162735415805, 0.6698337620266515, 0.6734708931164728,\n\t\t0.6771277734684463, 0.6808045103191123, 0.6845012114872953, 0.688217985377265,\n\t\t0.6919549409819159, 0.6957121878859629, 0.6994898362691555, 0.7032879969095076,\n\t\t0.7071067811865475, 0.7109463010845827, 0.7148066691959849, 0.718687998724491,\n\t\t0.7225904034885232, 0.7265139979245261, 0.7304588970903234, 0.7344252166684908,\n\t\t0.7384130729697496, 0.7424225829363761, 0.7464538641456323, 0.7505070348132126,\n\t\t0.7545822137967112, 0.7586795205991071, 0.762799075372269, 0.7669409989204777,\n\t\t0.7711054127039704, 0.7752924388424999, 0.7795022001189185, 0.7837348199827764,\n\t\t0.7879904225539431, 0.7922691326262467, 0.7965710756711334, 0.8008963778413465,\n\t\t0.805245165974627, 0.8096175675974316, 0.8140137109286738, 0.8184337248834821,\n\t\t0.8228777390769823, 0.8273458838280969, 0.8318382901633681, 0.8363550898207981,\n\t\t0.8408964152537144, 0.8454623996346523, 0.8500531768592616, 0.8546688815502312,\n\t\t0.8593096490612387, 0.8639756154809185, 0.8686669176368529, 0.8733836930995842,\n\t\t0.8781260801866495, 0.8828942179666361, 0.8876882462632604, 0.8925083056594671,\n\t\t0.8973545375015533, 0.9022270839033115, 0.9071260877501991, 0.9120516927035263,\n\t\t0.9170040432046711, 0.9219832844793128, 0.9269895625416926, 0.9320230241988943,\n\t\t0.9370838170551498, 0.9421720895161669, 0.9472879907934827, 0.9524316709088368,\n\t\t0.9576032806985735, 0.9628029718180622, 0.9680308967461471, 0.9732872087896164,\n\t\t0.9785720620876999, 0.9838856116165875, 0.9892280131939752, 0.9945994234836328,\n\t},\n\t// Schema 8:\n\t{\n\t\t0.5, 0.5013556375251013, 0.5027149505564014, 0.5040779490592088,\n\t\t0.5054446430258502, 0.5068150424757447, 0.5081891574554764, 0.509566998038869,\n\t\t0.5109485743270583, 0.5123338964485679, 0.5137229745593818, 0.5151158188430205,\n\t\t0.5165124395106142, 0.5179128468009786, 0.5193170509806894, 0.520725062344158,\n\t\t0.5221368912137069, 0.5235525479396449, 0.5249720429003435, 0.526395386502313,\n\t\t0.5278225891802786, 0.5292536613972564, 0.5306886136446309, 0.5321274564422321,\n\t\t0.5335702003384117, 0.5350168559101208, 0.5364674337629877, 0.5379219445313954,\n\t\t0.5393803988785598, 0.5408428074966075, 0.5423091811066545, 0.5437795304588847,\n\t\t0.5452538663326288, 0.5467321995364429, 0.5482145409081883, 0.549700901315111,\n\t\t0.5511912916539204, 0.5526857228508706, 0.5541842058618393, 0.5556867516724088,\n\t\t0.5571933712979462, 0.5587040757836845, 0.5602188762048033, 0.5617377836665098,\n\t\t0.5632608093041209, 0.564787964283144, 0.5663192597993595, 0.5678547070789026,\n\t\t0.5693943173783458, 0.5709381019847808, 0.572486072215902, 0.5740382394200894,\n\t\t0.5755946149764913, 0.5771552102951081, 0.5787200368168754, 0.5802891060137493,\n\t\t0.5818624293887887, 0.5834400184762408, 0.585021884841625, 0.5866080400818185,\n\t\t0.5881984958251406, 0.5897932637314379, 0.5913923554921704, 0.5929957828304968,\n\t\t0.5946035575013605, 0.5962156912915756, 0.5978321960199137, 0.5994530835371903,\n\t\t0.6010783657263515, 0.6027080545025619, 0.6043421618132907, 0.6059806996384005,\n\t\t0.6076236799902344, 0.6092711149137041, 0.6109230164863786, 0.6125793968185725,\n\t\t0.6142402680534349, 0.6159056423670379, 0.6175755319684665, 0.6192499490999082,\n\t\t0.620928906036742, 0.622612415087629, 0.6243004885946023, 0.6259931389331581,\n\t\t0.6276903785123455, 0.6293922197748583, 0.6310986751971253, 0.6328097572894031,\n\t\t0.6345254785958666, 0.6362458516947014, 0.637970889198196, 0.6397006037528346,\n\t\t0.6414350080393891, 0.6431741147730128, 0.6449179367033329, 0.6466664866145447,\n\t\t0.6484197773255048, 0.6501778216898253, 0.6519406325959679, 0.6537082229673385,\n\t\t0.6554806057623822, 0.6572577939746774, 0.659039800633032, 0.6608266388015788,\n\t\t0.6626183215798706, 0.6644148621029772, 0.6662162735415805, 0.6680225691020727,\n\t\t0.6698337620266515, 0.6716498655934177, 0.6734708931164728, 0.6752968579460171,\n\t\t0.6771277734684463, 0.6789636531064505, 0.6808045103191123, 0.6826503586020058,\n\t\t0.6845012114872953, 0.6863570825438342, 0.688217985377265, 0.690083933630119,\n\t\t0.6919549409819159, 0.6938310211492645, 0.6957121878859629, 0.6975984549830999,\n\t\t0.6994898362691555, 0.7013863456101023, 0.7032879969095076, 0.7051948041086352,\n\t\t0.7071067811865475, 0.7090239421602076, 0.7109463010845827, 0.7128738720527471,\n\t\t0.7148066691959849, 0.7167447066838943, 0.718687998724491, 0.7206365595643126,\n\t\t0.7225904034885232, 0.7245495448210174, 0.7265139979245261, 0.7284837772007218,\n\t\t0.7304588970903234, 0.7324393720732029, 0.7344252166684908, 0.7364164454346837,\n\t\t0.7384130729697496, 0.7404151139112358, 0.7424225829363761, 0.7444354947621984,\n\t\t0.7464538641456323, 0.7484777058836176, 0.7505070348132126, 0.7525418658117031,\n\t\t0.7545822137967112, 0.7566280937263048, 0.7586795205991071, 0.7607365094544071,\n\t\t0.762799075372269, 0.7648672334736434, 0.7669409989204777, 0.7690203869158282,\n\t\t0.7711054127039704, 0.7731960915705107, 0.7752924388424999, 0.7773944698885442,\n\t\t0.7795022001189185, 0.7816156449856788, 0.7837348199827764, 0.7858597406461707,\n\t\t0.7879904225539431, 0.7901268813264122, 0.7922691326262467, 0.7944171921585818,\n\t\t0.7965710756711334, 0.7987307989543135, 0.8008963778413465, 0.8030678282083853,\n\t\t0.805245165974627, 0.8074284071024302, 0.8096175675974316, 0.8118126635086642,\n\t\t0.8140137109286738, 0.8162207259936375, 0.8184337248834821, 0.820652723822003,\n\t\t0.8228777390769823, 0.8251087869603088, 0.8273458838280969, 0.8295890460808079,\n\t\t0.8318382901633681, 0.8340936325652911, 0.8363550898207981, 0.8386226785089391,\n\t\t0.8408964152537144, 0.8431763167241966, 0.8454623996346523, 0.8477546807446661,\n\t\t0.8500531768592616, 0.8523579048290255, 0.8546688815502312, 0.8569861239649629,\n\t\t0.8593096490612387, 0.8616394738731368, 0.8639756154809185, 0.8663180910111553,\n\t\t0.8686669176368529, 0.871022112577578, 0.8733836930995842, 0.8757516765159389,\n\t\t0.8781260801866495, 0.8805069215187917, 0.8828942179666361, 0.8852879870317771,\n\t\t0.8876882462632604, 0.890095013257712, 0.8925083056594671, 0.8949281411607002,\n\t\t0.8973545375015533, 0.8997875124702672, 0.9022270839033115, 0.9046732696855155,\n\t\t0.9071260877501991, 0.909585556079304, 0.9120516927035263, 0.9145245157024483,\n\t\t0.9170040432046711, 0.9194902933879467, 0.9219832844793128, 0.9244830347552253,\n\t\t0.9269895625416926, 0.92950288621441, 0.9320230241988943, 0.9345499949706191,\n\t\t0.9370838170551498, 0.93962450902828, 0.9421720895161669, 0.9447265771954693,\n\t\t0.9472879907934827, 0.9498563490882775, 0.9524316709088368, 0.9550139751351947,\n\t\t0.9576032806985735, 0.9601996065815236, 0.9628029718180622, 0.9654133954938133,\n\t\t0.9680308967461471, 0.9706554947643201, 0.9732872087896164, 0.9759260581154889,\n\t\t0.9785720620876999, 0.9812252401044634, 0.9838856116165875, 0.9865531961276168,\n\t\t0.9892280131939752, 0.9919100824251095, 0.9945994234836328, 0.9972960560854698,\n\t},\n}\n\n// The nativeHistogramBounds above can be generated with the code below.\n//\n// TODO(beorn7): It's tempting to actually use `go generate` to generate the\n// code above. However, this could lead to slightly different numbers on\n// different architectures. We still need to come to terms if we are fine with\n// that, or if we might prefer to specify precise numbers in the standard.\n//\n// var nativeHistogramBounds [][]float64 = make([][]float64, 9)\n//\n// func init() {\n// \t// Populate nativeHistogramBounds.\n// \tnumBuckets := 1\n// \tfor i := range nativeHistogramBounds {\n// \t\tbounds := []float64{0.5}\n// \t\tfactor := math.Exp2(math.Exp2(float64(-i)))\n// \t\tfor j := 0; j < numBuckets-1; j++ {\n// \t\t\tvar bound float64\n// \t\t\tif (j+1)%2 == 0 {\n// \t\t\t\t// Use previously calculated value for increased precision.\n// \t\t\t\tbound = nativeHistogramBounds[i-1][j/2+1]\n// \t\t\t} else {\n// \t\t\t\tbound = bounds[j] * factor\n// \t\t\t}\n// \t\t\tbounds = append(bounds, bound)\n// \t\t}\n// \t\tnumBuckets *= 2\n// \t\tnativeHistogramBounds[i] = bounds\n// \t}\n// }\n\n// A Histogram counts individual observations from an event or sample stream in\n// configurable static buckets (or in dynamic sparse buckets as part of the\n// experimental Native Histograms, see below for more details). Similar to a\n// Summary, it also provides a sum of observations and an observation count.\n//\n// On the Prometheus server, quantiles can be calculated from a Histogram using\n// the histogram_quantile PromQL function.\n//\n// Note that Histograms, in contrast to Summaries, can be aggregated in PromQL\n// (see the documentation for detailed procedures). However, Histograms require\n// the user to pre-define suitable buckets, and they are in general less\n// accurate. (Both problems are addressed by the experimental Native\n// Histograms. To use them, configure a NativeHistogramBucketFactor in the\n// HistogramOpts. They also require a Prometheus server v2.40+ with the\n// corresponding feature flag enabled.)\n//\n// The Observe method of a Histogram has a very low performance overhead in\n// comparison with the Observe method of a Summary.\n//\n// To create Histogram instances, use NewHistogram.\ntype Histogram interface {\n\tMetric\n\tCollector\n\n\t// Observe adds a single observation to the histogram. Observations are\n\t// usually positive or zero. Negative observations are accepted but\n\t// prevent current versions of Prometheus from properly detecting\n\t// counter resets in the sum of observations. (The experimental Native\n\t// Histograms handle negative observations properly.) See\n\t// https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations\n\t// for details.\n\tObserve(float64)\n}\n\n// bucketLabel is used for the label that defines the upper bound of a\n// bucket of a histogram (\"le\" -> \"less or equal\").\nconst bucketLabel = \"le\"\n\n// DefBuckets are the default Histogram buckets. The default buckets are\n// tailored to broadly measure the response time (in seconds) of a network\n// service. Most likely, however, you will be required to define buckets\n// customized to your use case.\nvar DefBuckets = []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10}\n\n// DefNativeHistogramZeroThreshold is the default value for\n// NativeHistogramZeroThreshold in the HistogramOpts.\n//\n// The value is 2^-128 (or 0.5*2^-127 in the actual IEEE 754 representation),\n// which is a bucket boundary at all possible resolutions.\nconst DefNativeHistogramZeroThreshold = 2.938735877055719e-39\n\n// NativeHistogramZeroThresholdZero can be used as NativeHistogramZeroThreshold\n// in the HistogramOpts to create a zero bucket of width zero, i.e. a zero\n// bucket that only receives observations of precisely zero.\nconst NativeHistogramZeroThresholdZero = -1\n\nvar errBucketLabelNotAllowed = fmt.Errorf(\n\t\"%q is not allowed as label name in histograms\", bucketLabel,\n)\n\n// LinearBuckets creates 'count' regular buckets, each 'width' wide, where the\n// lowest bucket has an upper bound of 'start'. The final +Inf bucket is not\n// counted and not included in the returned slice. The returned slice is meant\n// to be used for the Buckets field of HistogramOpts.\n//\n// The function panics if 'count' is zero or negative.\nfunc LinearBuckets(start, width float64, count int) []float64 {\n\tif count < 1 {\n\t\tpanic(\"LinearBuckets needs a positive count\")\n\t}\n\tbuckets := make([]float64, count)\n\tfor i := range buckets {\n\t\tbuckets[i] = start\n\t\tstart += width\n\t}\n\treturn buckets\n}\n\n// ExponentialBuckets creates 'count' regular buckets, where the lowest bucket\n// has an upper bound of 'start' and each following bucket's upper bound is\n// 'factor' times the previous bucket's upper bound. The final +Inf bucket is\n// not counted and not included in the returned slice. The returned slice is\n// meant to be used for the Buckets field of HistogramOpts.\n//\n// The function panics if 'count' is 0 or negative, if 'start' is 0 or negative,\n// or if 'factor' is less than or equal 1.\nfunc ExponentialBuckets(start, factor float64, count int) []float64 {\n\tif count < 1 {\n\t\tpanic(\"ExponentialBuckets needs a positive count\")\n\t}\n\tif start <= 0 {\n\t\tpanic(\"ExponentialBuckets needs a positive start value\")\n\t}\n\tif factor <= 1 {\n\t\tpanic(\"ExponentialBuckets needs a factor greater than 1\")\n\t}\n\tbuckets := make([]float64, count)\n\tfor i := range buckets {\n\t\tbuckets[i] = start\n\t\tstart *= factor\n\t}\n\treturn buckets\n}\n\n// ExponentialBucketsRange creates 'count' buckets, where the lowest bucket is\n// 'min' and the highest bucket is 'max'. The final +Inf bucket is not counted\n// and not included in the returned slice. The returned slice is meant to be\n// used for the Buckets field of HistogramOpts.\n//\n// The function panics if 'count' is 0 or negative, if 'min' is 0 or negative.\nfunc ExponentialBucketsRange(min, max float64, count int) []float64 {\n\tif count < 1 {\n\t\tpanic(\"ExponentialBucketsRange count needs a positive count\")\n\t}\n\tif min <= 0 {\n\t\tpanic(\"ExponentialBucketsRange min needs to be greater than 0\")\n\t}\n\n\t// Formula for exponential buckets.\n\t// max = min*growthFactor^(bucketCount-1)\n\n\t// We know max/min and highest bucket. Solve for growthFactor.\n\tgrowthFactor := math.Pow(max/min, 1.0/float64(count-1))\n\n\t// Now that we know growthFactor, solve for each bucket.\n\tbuckets := make([]float64, count)\n\tfor i := 1; i <= count; i++ {\n\t\tbuckets[i-1] = min * math.Pow(growthFactor, float64(i-1))\n\t}\n\treturn buckets\n}\n\n// HistogramOpts bundles the options for creating a Histogram metric. It is\n// mandatory to set Name to a non-empty string. All other fields are optional\n// and can safely be left at their zero value, although it is strongly\n// encouraged to set a Help string.\ntype HistogramOpts struct {\n\t// Namespace, Subsystem, and Name are components of the fully-qualified\n\t// name of the Histogram (created by joining these components with\n\t// \"_\"). Only Name is mandatory, the others merely help structuring the\n\t// name. Note that the fully-qualified name of the Histogram must be a\n\t// valid Prometheus metric name.\n\tNamespace string\n\tSubsystem string\n\tName string\n\n\t// Help provides information about this Histogram.\n\t//\n\t// Metrics with the same fully-qualified name must have the same Help\n\t// string.\n\tHelp string\n\n\t// ConstLabels are used to attach fixed labels to this metric. Metrics\n\t// with the same fully-qualified name must have the same label names in\n\t// their ConstLabels.\n\t//\n\t// ConstLabels are only used rarely. In particular, do not use them to\n\t// attach the same labels to all your metrics. Those use cases are\n\t// better covered by target labels set by the scraping Prometheus\n\t// server, or by one specific metric (e.g. a build_info or a\n\t// machine_role metric). See also\n\t// https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels\n\tConstLabels Labels\n\n\t// Buckets defines the buckets into which observations are counted. Each\n\t// element in the slice is the upper inclusive bound of a bucket. The\n\t// values must be sorted in strictly increasing order. There is no need\n\t// to add a highest bucket with +Inf bound, it will be added\n\t// implicitly. If Buckets is left as nil or set to a slice of length\n\t// zero, it is replaced by default buckets. The default buckets are\n\t// DefBuckets if no buckets for a native histogram (see below) are used,\n\t// otherwise the default is no buckets. (In other words, if you want to\n\t// use both reguler buckets and buckets for a native histogram, you have\n\t// to define the regular buckets here explicitly.)\n\tBuckets []float64\n\n\t// If NativeHistogramBucketFactor is greater than one, so-called sparse\n\t// buckets are used (in addition to the regular buckets, if defined\n\t// above). A Histogram with sparse buckets will be ingested as a Native\n\t// Histogram by a Prometheus server with that feature enabled (requires\n\t// Prometheus v2.40+). Sparse buckets are exponential buckets covering\n\t// the whole float64 range (with the exception of the “zero” bucket, see\n\t// SparseBucketsZeroThreshold below). From any one bucket to the next,\n\t// the width of the bucket grows by a constant\n\t// factor. NativeHistogramBucketFactor provides an upper bound for this\n\t// factor (exception see below). The smaller\n\t// NativeHistogramBucketFactor, the more buckets will be used and thus\n\t// the more costly the histogram will become. A generally good trade-off\n\t// between cost and accuracy is a value of 1.1 (each bucket is at most\n\t// 10% wider than the previous one), which will result in each power of\n\t// two divided into 8 buckets (e.g. there will be 8 buckets between 1\n\t// and 2, same as between 2 and 4, and 4 and 8, etc.).\n\t//\n\t// Details about the actually used factor: The factor is calculated as\n\t// 2^(2^n), where n is an integer number between (and including) -8 and\n\t// 4. n is chosen so that the resulting factor is the largest that is\n\t// still smaller or equal to NativeHistogramBucketFactor. Note that the\n\t// smallest possible factor is therefore approx. 1.00271 (i.e. 2^(2^-8)\n\t// ). If NativeHistogramBucketFactor is greater than 1 but smaller than\n\t// 2^(2^-8), then the actually used factor is still 2^(2^-8) even though\n\t// it is larger than the provided NativeHistogramBucketFactor.\n\t//\n\t// NOTE: Native Histograms are still an experimental feature. Their\n\t// behavior might still change without a major version\n\t// bump. Subsequently, all NativeHistogram... options here might still\n\t// change their behavior or name (or might completely disappear) without\n\t// a major version bump.\n\tNativeHistogramBucketFactor float64\n\t// All observations with an absolute value of less or equal\n\t// NativeHistogramZeroThreshold are accumulated into a “zero”\n\t// bucket. For best results, this should be close to a bucket\n\t// boundary. This is usually the case if picking a power of two. If\n\t// NativeHistogramZeroThreshold is left at zero,\n\t// DefSparseBucketsZeroThreshold is used as the threshold. To configure\n\t// a zero bucket with an actual threshold of zero (i.e. only\n\t// observations of precisely zero will go into the zero bucket), set\n\t// NativeHistogramZeroThreshold to the NativeHistogramZeroThresholdZero\n\t// constant (or any negative float value).\n\tNativeHistogramZeroThreshold float64\n\n\t// The remaining fields define a strategy to limit the number of\n\t// populated sparse buckets. If NativeHistogramMaxBucketNumber is left\n\t// at zero, the number of buckets is not limited. (Note that this might\n\t// lead to unbounded memory consumption if the values observed by the\n\t// Histogram are sufficiently wide-spread. In particular, this could be\n\t// used as a DoS attack vector. Where the observed values depend on\n\t// external inputs, it is highly recommended to set a\n\t// NativeHistogramMaxBucketNumber.) Once the set\n\t// NativeHistogramMaxBucketNumber is exceeded, the following strategy is\n\t// enacted: First, if the last reset (or the creation) of the histogram\n\t// is at least NativeHistogramMinResetDuration ago, then the whole\n\t// histogram is reset to its initial state (including regular\n\t// buckets). If less time has passed, or if\n\t// NativeHistogramMinResetDuration is zero, no reset is\n\t// performed. Instead, the zero threshold is increased sufficiently to\n\t// reduce the number of buckets to or below\n\t// NativeHistogramMaxBucketNumber, but not to more than\n\t// NativeHistogramMaxZeroThreshold. Thus, if\n\t// NativeHistogramMaxZeroThreshold is already at or below the current\n\t// zero threshold, nothing happens at this step. After that, if the\n\t// number of buckets still exceeds NativeHistogramMaxBucketNumber, the\n\t// resolution of the histogram is reduced by doubling the width of the\n\t// sparse buckets (up to a growth factor between one bucket to the next\n\t// of 2^(2^4) = 65536, see above).\n\tNativeHistogramMaxBucketNumber uint32\n\tNativeHistogramMinResetDuration time.Duration\n\tNativeHistogramMaxZeroThreshold float64\n}\n\n// NewHistogram creates a new Histogram based on the provided HistogramOpts. It\n// panics if the buckets in HistogramOpts are not in strictly increasing order.\n//\n// The returned implementation also implements ExemplarObserver. It is safe to\n// perform the corresponding type assertion. Exemplars are tracked separately\n// for each bucket.\nfunc NewHistogram(opts HistogramOpts) Histogram {\n\treturn newHistogram(\n\t\tNewDesc(\n\t\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\t\topts.Help,\n\t\t\tnil,\n\t\t\topts.ConstLabels,\n\t\t),\n\t\topts,\n\t)\n}\n\nfunc newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogram {\n\tif len(desc.variableLabels) != len(labelValues) {\n\t\tpanic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, labelValues))\n\t}\n\n\tfor _, n := range desc.variableLabels {\n\t\tif n == bucketLabel {\n\t\t\tpanic(errBucketLabelNotAllowed)\n\t\t}\n\t}\n\tfor _, lp := range desc.constLabelPairs {\n\t\tif lp.GetName() == bucketLabel {\n\t\t\tpanic(errBucketLabelNotAllowed)\n\t\t}\n\t}\n\n\th := &histogram{\n\t\tdesc: desc,\n\t\tupperBounds: opts.Buckets,\n\t\tlabelPairs: MakeLabelPairs(desc, labelValues),\n\t\tnativeHistogramMaxBuckets: opts.NativeHistogramMaxBucketNumber,\n\t\tnativeHistogramMaxZeroThreshold: opts.NativeHistogramMaxZeroThreshold,\n\t\tnativeHistogramMinResetDuration: opts.NativeHistogramMinResetDuration,\n\t\tlastResetTime: time.Now(),\n\t\tnow: time.Now,\n\t}\n\tif len(h.upperBounds) == 0 && opts.NativeHistogramBucketFactor <= 1 {\n\t\th.upperBounds = DefBuckets\n\t}\n\tif opts.NativeHistogramBucketFactor <= 1 {\n\t\th.nativeHistogramSchema = math.MinInt32 // To mark that there are no sparse buckets.\n\t} else {\n\t\tswitch {\n\t\tcase opts.NativeHistogramZeroThreshold > 0:\n\t\t\th.nativeHistogramZeroThreshold = opts.NativeHistogramZeroThreshold\n\t\tcase opts.NativeHistogramZeroThreshold == 0:\n\t\t\th.nativeHistogramZeroThreshold = DefNativeHistogramZeroThreshold\n\t\t} // Leave h.nativeHistogramZeroThreshold at 0 otherwise.\n\t\th.nativeHistogramSchema = pickSchema(opts.NativeHistogramBucketFactor)\n\t}\n\tfor i, upperBound := range h.upperBounds {\n\t\tif i < len(h.upperBounds)-1 {\n\t\t\tif upperBound >= h.upperBounds[i+1] {\n\t\t\t\tpanic(fmt.Errorf(\n\t\t\t\t\t\"histogram buckets must be in increasing order: %f >= %f\",\n\t\t\t\t\tupperBound, h.upperBounds[i+1],\n\t\t\t\t))\n\t\t\t}\n\t\t} else {\n\t\t\tif math.IsInf(upperBound, +1) {\n\t\t\t\t// The +Inf bucket is implicit. Remove it here.\n\t\t\t\th.upperBounds = h.upperBounds[:i]\n\t\t\t}\n\t\t}\n\t}\n\t// Finally we know the final length of h.upperBounds and can make buckets\n\t// for both counts as well as exemplars:\n\th.counts[0] = &histogramCounts{\n\t\tbuckets: make([]uint64, len(h.upperBounds)),\n\t\tnativeHistogramZeroThresholdBits: math.Float64bits(h.nativeHistogramZeroThreshold),\n\t\tnativeHistogramSchema: h.nativeHistogramSchema,\n\t}\n\th.counts[1] = &histogramCounts{\n\t\tbuckets: make([]uint64, len(h.upperBounds)),\n\t\tnativeHistogramZeroThresholdBits: math.Float64bits(h.nativeHistogramZeroThreshold),\n\t\tnativeHistogramSchema: h.nativeHistogramSchema,\n\t}\n\th.exemplars = make([]atomic.Value, len(h.upperBounds)+1)\n\n\th.init(h) // Init self-collection.\n\treturn h\n}\n\ntype histogramCounts struct {\n\t// Order in this struct matters for the alignment required by atomic\n\t// operations, see http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\n\t// sumBits contains the bits of the float64 representing the sum of all\n\t// observations.\n\tsumBits uint64\n\tcount uint64\n\n\t// nativeHistogramZeroBucket counts all (positive and negative)\n\t// observations in the zero bucket (with an absolute value less or equal\n\t// the current threshold, see next field.\n\tnativeHistogramZeroBucket uint64\n\t// nativeHistogramZeroThresholdBits is the bit pattern of the current\n\t// threshold for the zero bucket. It's initially equal to\n\t// nativeHistogramZeroThreshold but may change according to the bucket\n\t// count limitation strategy.\n\tnativeHistogramZeroThresholdBits uint64\n\t// nativeHistogramSchema may change over time according to the bucket\n\t// count limitation strategy and therefore has to be saved here.\n\tnativeHistogramSchema int32\n\t// Number of (positive and negative) sparse buckets.\n\tnativeHistogramBucketsNumber uint32\n\n\t// Regular buckets.\n\tbuckets []uint64\n\n\t// The sparse buckets for native histograms are implemented with a\n\t// sync.Map for now. A dedicated data structure will likely be more\n\t// efficient. There are separate maps for negative and positive\n\t// observations. The map's value is an *int64, counting observations in\n\t// that bucket. (Note that we don't use uint64 as an int64 won't\n\t// overflow in practice, and working with signed numbers from the\n\t// beginning simplifies the handling of deltas.) The map's key is the\n\t// index of the bucket according to the used\n\t// nativeHistogramSchema. Index 0 is for an upper bound of 1.\n\tnativeHistogramBucketsPositive, nativeHistogramBucketsNegative sync.Map\n}\n\n// observe manages the parts of observe that only affects\n// histogramCounts. doSparse is true if sparse buckets should be done,\n// too.\nfunc (hc *histogramCounts) observe(v float64, bucket int, doSparse bool) {\n\tif bucket < len(hc.buckets) {\n\t\tatomic.AddUint64(&hc.buckets[bucket], 1)\n\t}\n\tatomicAddFloat(&hc.sumBits, v)\n\tif doSparse && !math.IsNaN(v) {\n\t\tvar (\n\t\t\tkey int\n\t\t\tschema = atomic.LoadInt32(&hc.nativeHistogramSchema)\n\t\t\tzeroThreshold = math.Float64frombits(atomic.LoadUint64(&hc.nativeHistogramZeroThresholdBits))\n\t\t\tbucketCreated, isInf bool\n\t\t)\n\t\tif math.IsInf(v, 0) {\n\t\t\t// Pretend v is MaxFloat64 but later increment key by one.\n\t\t\tif math.IsInf(v, +1) {\n\t\t\t\tv = math.MaxFloat64\n\t\t\t} else {\n\t\t\t\tv = -math.MaxFloat64\n\t\t\t}\n\t\t\tisInf = true\n\t\t}\n\t\tfrac, exp := math.Frexp(math.Abs(v))\n\t\tif schema > 0 {\n\t\t\tbounds := nativeHistogramBounds[schema]\n\t\t\tkey = sort.SearchFloat64s(bounds, frac) + (exp-1)*len(bounds)\n\t\t} else {\n\t\t\tkey = exp\n\t\t\tif frac == 0.5 {\n\t\t\t\tkey--\n\t\t\t}\n\t\t\tdiv := 1 << -schema\n\t\t\tkey = (key + div - 1) / div\n\t\t}\n\t\tif isInf {\n\t\t\tkey++\n\t\t}\n\t\tswitch {\n\t\tcase v > zeroThreshold:\n\t\t\tbucketCreated = addToBucket(&hc.nativeHistogramBucketsPositive, key, 1)\n\t\tcase v < -zeroThreshold:\n\t\t\tbucketCreated = addToBucket(&hc.nativeHistogramBucketsNegative, key, 1)\n\t\tdefault:\n\t\t\tatomic.AddUint64(&hc.nativeHistogramZeroBucket, 1)\n\t\t}\n\t\tif bucketCreated {\n\t\t\tatomic.AddUint32(&hc.nativeHistogramBucketsNumber, 1)\n\t\t}\n\t}\n\t// Increment count last as we take it as a signal that the observation\n\t// is complete.\n\tatomic.AddUint64(&hc.count, 1)\n}\n\ntype histogram struct {\n\t// countAndHotIdx enables lock-free writes with use of atomic updates.\n\t// The most significant bit is the hot index [0 or 1] of the count field\n\t// below. Observe calls update the hot one. All remaining bits count the\n\t// number of Observe calls. Observe starts by incrementing this counter,\n\t// and finish by incrementing the count field in the respective\n\t// histogramCounts, as a marker for completion.\n\t//\n\t// Calls of the Write method (which are non-mutating reads from the\n\t// perspective of the histogram) swap the hot–cold under the writeMtx\n\t// lock. A cooldown is awaited (while locked) by comparing the number of\n\t// observations with the initiation count. Once they match, then the\n\t// last observation on the now cool one has completed. All cold fields must\n\t// be merged into the new hot before releasing writeMtx.\n\t//\n\t// Fields with atomic access first! See alignment constraint:\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\tcountAndHotIdx uint64\n\n\tselfCollector\n\tdesc *Desc\n\n\t// Only used in the Write method and for sparse bucket management.\n\tmtx sync.Mutex\n\n\t// Two counts, one is \"hot\" for lock-free observations, the other is\n\t// \"cold\" for writing out a dto.Metric. It has to be an array of\n\t// pointers to guarantee 64bit alignment of the histogramCounts, see\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG.\n\tcounts [2]*histogramCounts\n\n\tupperBounds []float64\n\tlabelPairs []*dto.LabelPair\n\texemplars []atomic.Value // One more than buckets (to include +Inf), each a *dto.Exemplar.\n\tnativeHistogramSchema int32 // The initial schema. Set to math.MinInt32 if no sparse buckets are used.\n\tnativeHistogramZeroThreshold float64 // The initial zero threshold.\n\tnativeHistogramMaxZeroThreshold float64\n\tnativeHistogramMaxBuckets uint32\n\tnativeHistogramMinResetDuration time.Duration\n\tlastResetTime time.Time // Protected by mtx.\n\n\tnow func() time.Time // To mock out time.Now() for testing.\n}\n\nfunc (h *histogram) Desc() *Desc {\n\treturn h.desc\n}\n\nfunc (h *histogram) Observe(v float64) {\n\th.observe(v, h.findBucket(v))\n}\n\nfunc (h *histogram) ObserveWithExemplar(v float64, e Labels) {\n\ti := h.findBucket(v)\n\th.observe(v, i)\n\th.updateExemplar(v, i, e)\n}\n\nfunc (h *histogram) Write(out *dto.Metric) error {\n\t// For simplicity, we protect this whole method by a mutex. It is not in\n\t// the hot path, i.e. Observe is called much more often than Write. The\n\t// complication of making Write lock-free isn't worth it, if possible at\n\t// all.\n\th.mtx.Lock()\n\tdefer h.mtx.Unlock()\n\n\t// Adding 1<<63 switches the hot index (from 0 to 1 or from 1 to 0)\n\t// without touching the count bits. See the struct comments for a full\n\t// description of the algorithm.\n\tn := atomic.AddUint64(&h.countAndHotIdx, 1<<63)\n\t// count is contained unchanged in the lower 63 bits.\n\tcount := n & ((1 << 63) - 1)\n\t// The most significant bit tells us which counts is hot. The complement\n\t// is thus the cold one.\n\thotCounts := h.counts[n>>63]\n\tcoldCounts := h.counts[(^n)>>63]\n\n\twaitForCooldown(count, coldCounts)\n\n\this := &dto.Histogram{\n\t\tBucket: make([]*dto.Bucket, len(h.upperBounds)),\n\t\tSampleCount: proto.Uint64(count),\n\t\tSampleSum: proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),\n\t}\n\tout.Histogram = his\n\tout.Label = h.labelPairs\n\n\tvar cumCount uint64\n\tfor i, upperBound := range h.upperBounds {\n\t\tcumCount += atomic.LoadUint64(&coldCounts.buckets[i])\n\t\this.Bucket[i] = &dto.Bucket{\n\t\t\tCumulativeCount: proto.Uint64(cumCount),\n\t\t\tUpperBound: proto.Float64(upperBound),\n\t\t}\n\t\tif e := h.exemplars[i].Load(); e != nil {\n\t\t\this.Bucket[i].Exemplar = e.(*dto.Exemplar)\n\t\t}\n\t}\n\t// If there is an exemplar for the +Inf bucket, we have to add that bucket explicitly.\n\tif e := h.exemplars[len(h.upperBounds)].Load(); e != nil {\n\t\tb := &dto.Bucket{\n\t\t\tCumulativeCount: proto.Uint64(count),\n\t\t\tUpperBound: proto.Float64(math.Inf(1)),\n\t\t\tExemplar: e.(*dto.Exemplar),\n\t\t}\n\t\this.Bucket = append(his.Bucket, b)\n\t}\n\tif h.nativeHistogramSchema > math.MinInt32 {\n\t\this.ZeroThreshold = proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.nativeHistogramZeroThresholdBits)))\n\t\this.Schema = proto.Int32(atomic.LoadInt32(&coldCounts.nativeHistogramSchema))\n\t\tzeroBucket := atomic.LoadUint64(&coldCounts.nativeHistogramZeroBucket)\n\n\t\tdefer func() {\n\t\t\tcoldCounts.nativeHistogramBucketsPositive.Range(addAndReset(&hotCounts.nativeHistogramBucketsPositive, &hotCounts.nativeHistogramBucketsNumber))\n\t\t\tcoldCounts.nativeHistogramBucketsNegative.Range(addAndReset(&hotCounts.nativeHistogramBucketsNegative, &hotCounts.nativeHistogramBucketsNumber))\n\t\t}()\n\n\t\this.ZeroCount = proto.Uint64(zeroBucket)\n\t\this.NegativeSpan, his.NegativeDelta = makeBuckets(&coldCounts.nativeHistogramBucketsNegative)\n\t\this.PositiveSpan, his.PositiveDelta = makeBuckets(&coldCounts.nativeHistogramBucketsPositive)\n\t}\n\taddAndResetCounts(hotCounts, coldCounts)\n\treturn nil\n}\n\n// findBucket returns the index of the bucket for the provided value, or\n// len(h.upperBounds) for the +Inf bucket.\nfunc (h *histogram) findBucket(v float64) int {\n\t// TODO(beorn7): For small numbers of buckets (<30), a linear search is\n\t// slightly faster than the binary search. If we really care, we could\n\t// switch from one search strategy to the other depending on the number\n\t// of buckets.\n\t//\n\t// Microbenchmarks (BenchmarkHistogramNoLabels):\n\t// 11 buckets: 38.3 ns/op linear - binary 48.7 ns/op\n\t// 100 buckets: 78.1 ns/op linear - binary 54.9 ns/op\n\t// 300 buckets: 154 ns/op linear - binary 61.6 ns/op\n\treturn sort.SearchFloat64s(h.upperBounds, v)\n}\n\n// observe is the implementation for Observe without the findBucket part.\nfunc (h *histogram) observe(v float64, bucket int) {\n\t// Do not add to sparse buckets for NaN observations.\n\tdoSparse := h.nativeHistogramSchema > math.MinInt32 && !math.IsNaN(v)\n\t// We increment h.countAndHotIdx so that the counter in the lower\n\t// 63 bits gets incremented. At the same time, we get the new value\n\t// back, which we can use to find the currently-hot counts.\n\tn := atomic.AddUint64(&h.countAndHotIdx, 1)\n\thotCounts := h.counts[n>>63]\n\thotCounts.observe(v, bucket, doSparse)\n\tif doSparse {\n\t\th.limitBuckets(hotCounts, v, bucket)\n\t}\n}\n\n// limitSparsebuckets applies a strategy to limit the number of populated sparse\n// buckets. It's generally best effort, and there are situations where the\n// number can go higher (if even the lowest resolution isn't enough to reduce\n// the number sufficiently, or if the provided counts aren't fully updated yet\n// by a concurrently happening Write call).\nfunc (h *histogram) limitBuckets(counts *histogramCounts, value float64, bucket int) {\n\tif h.nativeHistogramMaxBuckets == 0 {\n\t\treturn // No limit configured.\n\t}\n\tif h.nativeHistogramMaxBuckets >= atomic.LoadUint32(&counts.nativeHistogramBucketsNumber) {\n\t\treturn // Bucket limit not exceeded yet.\n\t}\n\n\th.mtx.Lock()\n\tdefer h.mtx.Unlock()\n\n\t// The hot counts might have been swapped just before we acquired the\n\t// lock. Re-fetch the hot counts first...\n\tn := atomic.LoadUint64(&h.countAndHotIdx)\n\thotIdx := n >> 63\n\tcoldIdx := (^n) >> 63\n\thotCounts := h.counts[hotIdx]\n\tcoldCounts := h.counts[coldIdx]\n\t// ...and then check again if we really have to reduce the bucket count.\n\tif h.nativeHistogramMaxBuckets >= atomic.LoadUint32(&hotCounts.nativeHistogramBucketsNumber) {\n\t\treturn // Bucket limit not exceeded after all.\n\t}\n\t// Try the various strategies in order.\n\tif h.maybeReset(hotCounts, coldCounts, coldIdx, value, bucket) {\n\t\treturn\n\t}\n\tif h.maybeWidenZeroBucket(hotCounts, coldCounts) {\n\t\treturn\n\t}\n\th.doubleBucketWidth(hotCounts, coldCounts)\n}\n\n// maybeReset resests the whole histogram if at least h.nativeHistogramMinResetDuration\n// has been passed. It returns true if the histogram has been reset. The caller\n// must have locked h.mtx.\nfunc (h *histogram) maybeReset(hot, cold *histogramCounts, coldIdx uint64, value float64, bucket int) bool {\n\t// We are using the possibly mocked h.now() rather than\n\t// time.Since(h.lastResetTime) to enable testing.\n\tif h.nativeHistogramMinResetDuration == 0 || h.now().Sub(h.lastResetTime) < h.nativeHistogramMinResetDuration {\n\t\treturn false\n\t}\n\t// Completely reset coldCounts.\n\th.resetCounts(cold)\n\t// Repeat the latest observation to not lose it completely.\n\tcold.observe(value, bucket, true)\n\t// Make coldCounts the new hot counts while ressetting countAndHotIdx.\n\tn := atomic.SwapUint64(&h.countAndHotIdx, (coldIdx<<63)+1)\n\tcount := n & ((1 << 63) - 1)\n\twaitForCooldown(count, hot)\n\t// Finally, reset the formerly hot counts, too.\n\th.resetCounts(hot)\n\th.lastResetTime = h.now()\n\treturn true\n}\n\n// maybeWidenZeroBucket widens the zero bucket until it includes the existing\n// buckets closest to the zero bucket (which could be two, if an equidistant\n// negative and a positive bucket exists, but usually it's only one bucket to be\n// merged into the new wider zero bucket). h.nativeHistogramMaxZeroThreshold\n// limits how far the zero bucket can be extended, and if that's not enough to\n// include an existing bucket, the method returns false. The caller must have\n// locked h.mtx.\nfunc (h *histogram) maybeWidenZeroBucket(hot, cold *histogramCounts) bool {\n\tcurrentZeroThreshold := math.Float64frombits(atomic.LoadUint64(&hot.nativeHistogramZeroThresholdBits))\n\tif currentZeroThreshold >= h.nativeHistogramMaxZeroThreshold {\n\t\treturn false\n\t}\n\t// Find the key of the bucket closest to zero.\n\tsmallestKey := findSmallestKey(&hot.nativeHistogramBucketsPositive)\n\tsmallestNegativeKey := findSmallestKey(&hot.nativeHistogramBucketsNegative)\n\tif smallestNegativeKey < smallestKey {\n\t\tsmallestKey = smallestNegativeKey\n\t}\n\tif smallestKey == math.MaxInt32 {\n\t\treturn false\n\t}\n\tnewZeroThreshold := getLe(smallestKey, atomic.LoadInt32(&hot.nativeHistogramSchema))\n\tif newZeroThreshold > h.nativeHistogramMaxZeroThreshold {\n\t\treturn false // New threshold would exceed the max threshold.\n\t}\n\tatomic.StoreUint64(&cold.nativeHistogramZeroThresholdBits, math.Float64bits(newZeroThreshold))\n\t// Remove applicable buckets.\n\tif _, loaded := cold.nativeHistogramBucketsNegative.LoadAndDelete(smallestKey); loaded {\n\t\tatomicDecUint32(&cold.nativeHistogramBucketsNumber)\n\t}\n\tif _, loaded := cold.nativeHistogramBucketsPositive.LoadAndDelete(smallestKey); loaded {\n\t\tatomicDecUint32(&cold.nativeHistogramBucketsNumber)\n\t}\n\t// Make cold counts the new hot counts.\n\tn := atomic.AddUint64(&h.countAndHotIdx, 1<<63)\n\tcount := n & ((1 << 63) - 1)\n\t// Swap the pointer names to represent the new roles and make\n\t// the rest less confusing.\n\thot, cold = cold, hot\n\twaitForCooldown(count, cold)\n\t// Add all the now cold counts to the new hot counts...\n\taddAndResetCounts(hot, cold)\n\t// ...adjust the new zero threshold in the cold counts, too...\n\tatomic.StoreUint64(&cold.nativeHistogramZeroThresholdBits, math.Float64bits(newZeroThreshold))\n\t// ...and then merge the newly deleted buckets into the wider zero\n\t// bucket.\n\tmergeAndDeleteOrAddAndReset := func(hotBuckets, coldBuckets *sync.Map) func(k, v interface{}) bool {\n\t\treturn func(k, v interface{}) bool {\n\t\t\tkey := k.(int)\n\t\t\tbucket := v.(*int64)\n\t\t\tif key == smallestKey {\n\t\t\t\t// Merge into hot zero bucket...\n\t\t\t\tatomic.AddUint64(&hot.nativeHistogramZeroBucket, uint64(atomic.LoadInt64(bucket)))\n\t\t\t\t// ...and delete from cold counts.\n\t\t\t\tcoldBuckets.Delete(key)\n\t\t\t\tatomicDecUint32(&cold.nativeHistogramBucketsNumber)\n\t\t\t} else {\n\t\t\t\t// Add to corresponding hot bucket...\n\t\t\t\tif addToBucket(hotBuckets, key, atomic.LoadInt64(bucket)) {\n\t\t\t\t\tatomic.AddUint32(&hot.nativeHistogramBucketsNumber, 1)\n\t\t\t\t}\n\t\t\t\t// ...and reset cold bucket.\n\t\t\t\tatomic.StoreInt64(bucket, 0)\n\t\t\t}\n\t\t\treturn true\n\t\t}\n\t}\n\n\tcold.nativeHistogramBucketsPositive.Range(mergeAndDeleteOrAddAndReset(&hot.nativeHistogramBucketsPositive, &cold.nativeHistogramBucketsPositive))\n\tcold.nativeHistogramBucketsNegative.Range(mergeAndDeleteOrAddAndReset(&hot.nativeHistogramBucketsNegative, &cold.nativeHistogramBucketsNegative))\n\treturn true\n}\n\n// doubleBucketWidth doubles the bucket width (by decrementing the schema\n// number). Note that very sparse buckets could lead to a low reduction of the\n// bucket count (or even no reduction at all). The method does nothing if the\n// schema is already -4.\nfunc (h *histogram) doubleBucketWidth(hot, cold *histogramCounts) {\n\tcoldSchema := atomic.LoadInt32(&cold.nativeHistogramSchema)\n\tif coldSchema == -4 {\n\t\treturn // Already at lowest resolution.\n\t}\n\tcoldSchema--\n\tatomic.StoreInt32(&cold.nativeHistogramSchema, coldSchema)\n\t// Play it simple and just delete all cold buckets.\n\tatomic.StoreUint32(&cold.nativeHistogramBucketsNumber, 0)\n\tdeleteSyncMap(&cold.nativeHistogramBucketsNegative)\n\tdeleteSyncMap(&cold.nativeHistogramBucketsPositive)\n\t// Make coldCounts the new hot counts.\n\tn := atomic.AddUint64(&h.countAndHotIdx, 1<<63)\n\tcount := n & ((1 << 63) - 1)\n\t// Swap the pointer names to represent the new roles and make\n\t// the rest less confusing.\n\thot, cold = cold, hot\n\twaitForCooldown(count, cold)\n\t// Add all the now cold counts to the new hot counts...\n\taddAndResetCounts(hot, cold)\n\t// ...adjust the schema in the cold counts, too...\n\tatomic.StoreInt32(&cold.nativeHistogramSchema, coldSchema)\n\t// ...and then merge the cold buckets into the wider hot buckets.\n\tmerge := func(hotBuckets *sync.Map) func(k, v interface{}) bool {\n\t\treturn func(k, v interface{}) bool {\n\t\t\tkey := k.(int)\n\t\t\tbucket := v.(*int64)\n\t\t\t// Adjust key to match the bucket to merge into.\n\t\t\tif key > 0 {\n\t\t\t\tkey++\n\t\t\t}\n\t\t\tkey /= 2\n\t\t\t// Add to corresponding hot bucket.\n\t\t\tif addToBucket(hotBuckets, key, atomic.LoadInt64(bucket)) {\n\t\t\t\tatomic.AddUint32(&hot.nativeHistogramBucketsNumber, 1)\n\t\t\t}\n\t\t\treturn true\n\t\t}\n\t}\n\n\tcold.nativeHistogramBucketsPositive.Range(merge(&hot.nativeHistogramBucketsPositive))\n\tcold.nativeHistogramBucketsNegative.Range(merge(&hot.nativeHistogramBucketsNegative))\n\t// Play it simple again and just delete all cold buckets.\n\tatomic.StoreUint32(&cold.nativeHistogramBucketsNumber, 0)\n\tdeleteSyncMap(&cold.nativeHistogramBucketsNegative)\n\tdeleteSyncMap(&cold.nativeHistogramBucketsPositive)\n}\n\nfunc (h *histogram) resetCounts(counts *histogramCounts) {\n\tatomic.StoreUint64(&counts.sumBits, 0)\n\tatomic.StoreUint64(&counts.count, 0)\n\tatomic.StoreUint64(&counts.nativeHistogramZeroBucket, 0)\n\tatomic.StoreUint64(&counts.nativeHistogramZeroThresholdBits, math.Float64bits(h.nativeHistogramZeroThreshold))\n\tatomic.StoreInt32(&counts.nativeHistogramSchema, h.nativeHistogramSchema)\n\tatomic.StoreUint32(&counts.nativeHistogramBucketsNumber, 0)\n\tfor i := range h.upperBounds {\n\t\tatomic.StoreUint64(&counts.buckets[i], 0)\n\t}\n\tdeleteSyncMap(&counts.nativeHistogramBucketsNegative)\n\tdeleteSyncMap(&counts.nativeHistogramBucketsPositive)\n}\n\n// updateExemplar replaces the exemplar for the provided bucket. With empty\n// labels, it's a no-op. It panics if any of the labels is invalid.\nfunc (h *histogram) updateExemplar(v float64, bucket int, l Labels) {\n\tif l == nil {\n\t\treturn\n\t}\n\te, err := newExemplar(v, h.now(), l)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\th.exemplars[bucket].Store(e)\n}\n\n// HistogramVec is a Collector that bundles a set of Histograms that all share the\n// same Desc, but have different values for their variable labels. This is used\n// if you want to count the same thing partitioned by various dimensions\n// (e.g. HTTP request latencies, partitioned by status code and method). Create\n// instances with NewHistogramVec.\ntype HistogramVec struct {\n\t*MetricVec\n}\n\n// NewHistogramVec creates a new HistogramVec based on the provided HistogramOpts and\n// partitioned by the given label names.\nfunc NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec {\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tlabelNames,\n\t\topts.ConstLabels,\n\t)\n\treturn &HistogramVec{\n\t\tMetricVec: NewMetricVec(desc, func(lvs ...string) Metric {\n\t\t\treturn newHistogram(desc, opts, lvs...)\n\t\t}),\n\t}\n}\n\n// GetMetricWithLabelValues returns the Histogram for the given slice of label\n// values (same order as the variable labels in Desc). If that combination of\n// label values is accessed for the first time, a new Histogram is created.\n//\n// It is possible to call this method without using the returned Histogram to only\n// create the new Histogram but leave it at its starting value, a Histogram without\n// any observations.\n//\n// Keeping the Histogram for later use is possible (and should be considered if\n// performance is critical), but keep in mind that Reset, DeleteLabelValues and\n// Delete can be used to delete the Histogram from the HistogramVec. In that case, the\n// Histogram will still exist, but it will not be exported anymore, even if a\n// Histogram with the same label values is created later. See also the CounterVec\n// example.\n//\n// An error is returned if the number of label values is not the same as the\n// number of variable labels in Desc (minus any curried labels).\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as\n// an alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\n// See also the GaugeVec example.\nfunc (v *HistogramVec) GetMetricWithLabelValues(lvs ...string) (Observer, error) {\n\tmetric, err := v.MetricVec.GetMetricWithLabelValues(lvs...)\n\tif metric != nil {\n\t\treturn metric.(Observer), err\n\t}\n\treturn nil, err\n}\n\n// GetMetricWith returns the Histogram for the given Labels map (the label names\n// must match those of the variable labels in Desc). If that label map is\n// accessed for the first time, a new Histogram is created. Implications of\n// creating a Histogram without using it and keeping the Histogram for later use\n// are the same as for GetMetricWithLabelValues.\n//\n// An error is returned if the number and names of the Labels are inconsistent\n// with those of the variable labels in Desc (minus any curried labels).\n//\n// This method is used for the same purpose as\n// GetMetricWithLabelValues(...string). See there for pros and cons of the two\n// methods.\nfunc (v *HistogramVec) GetMetricWith(labels Labels) (Observer, error) {\n\tmetric, err := v.MetricVec.GetMetricWith(labels)\n\tif metric != nil {\n\t\treturn metric.(Observer), err\n\t}\n\treturn nil, err\n}\n\n// WithLabelValues works as GetMetricWithLabelValues, but panics where\n// GetMetricWithLabelValues would have returned an error. Not returning an\n// error allows shortcuts like\n//\n//\tmyVec.WithLabelValues(\"404\", \"GET\").Observe(42.21)\nfunc (v *HistogramVec) WithLabelValues(lvs ...string) Observer {\n\th, err := v.GetMetricWithLabelValues(lvs...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn h\n}\n\n// With works as GetMetricWith but panics where GetMetricWithLabels would have\n// returned an error. Not returning an error allows shortcuts like\n//\n//\tmyVec.With(prometheus.Labels{\"code\": \"404\", \"method\": \"GET\"}).Observe(42.21)\nfunc (v *HistogramVec) With(labels Labels) Observer {\n\th, err := v.GetMetricWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn h\n}\n\n// CurryWith returns a vector curried with the provided labels, i.e. the\n// returned vector has those labels pre-set for all labeled operations performed\n// on it. The cardinality of the curried vector is reduced accordingly. The\n// order of the remaining labels stays the same (just with the curried labels\n// taken out of the sequence – which is relevant for the\n// (GetMetric)WithLabelValues methods). It is possible to curry a curried\n// vector, but only with labels not yet used for currying before.\n//\n// The metrics contained in the HistogramVec are shared between the curried and\n// uncurried vectors. They are just accessed differently. Curried and uncurried\n// vectors behave identically in terms of collection. Only one must be\n// registered with a given registry (usually the uncurried version). The Reset\n// method deletes all metrics, even if called on a curried vector.\nfunc (v *HistogramVec) CurryWith(labels Labels) (ObserverVec, error) {\n\tvec, err := v.MetricVec.CurryWith(labels)\n\tif vec != nil {\n\t\treturn &HistogramVec{vec}, err\n\t}\n\treturn nil, err\n}\n\n// MustCurryWith works as CurryWith but panics where CurryWith would have\n// returned an error.\nfunc (v *HistogramVec) MustCurryWith(labels Labels) ObserverVec {\n\tvec, err := v.CurryWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn vec\n}\n\ntype constHistogram struct {\n\tdesc *Desc\n\tcount uint64\n\tsum float64\n\tbuckets map[float64]uint64\n\tlabelPairs []*dto.LabelPair\n}\n\nfunc (h *constHistogram) Desc() *Desc {\n\treturn h.desc\n}\n\nfunc (h *constHistogram) Write(out *dto.Metric) error {\n\this := &dto.Histogram{}\n\n\tbuckets := make([]*dto.Bucket, 0, len(h.buckets))\n\n\this.SampleCount = proto.Uint64(h.count)\n\this.SampleSum = proto.Float64(h.sum)\n\tfor upperBound, count := range h.buckets {\n\t\tbuckets = append(buckets, &dto.Bucket{\n\t\t\tCumulativeCount: proto.Uint64(count),\n\t\t\tUpperBound: proto.Float64(upperBound),\n\t\t})\n\t}\n\n\tif len(buckets) > 0 {\n\t\tsort.Sort(buckSort(buckets))\n\t}\n\this.Bucket = buckets\n\n\tout.Histogram = his\n\tout.Label = h.labelPairs\n\n\treturn nil\n}\n\n// NewConstHistogram returns a metric representing a Prometheus histogram with\n// fixed values for the count, sum, and bucket counts. As those parameters\n// cannot be changed, the returned value does not implement the Histogram\n// interface (but only the Metric interface). Users of this package will not\n// have much use for it in regular operations. However, when implementing custom\n// Collectors, it is useful as a throw-away metric that is generated on the fly\n// to send it to Prometheus in the Collect method.\n//\n// buckets is a map of upper bounds to cumulative counts, excluding the +Inf\n// bucket. The +Inf bucket is implicit, and its value is equal to the provided count.\n//\n// NewConstHistogram returns an error if the length of labelValues is not\n// consistent with the variable labels in Desc or if Desc is invalid.\nfunc NewConstHistogram(\n\tdesc *Desc,\n\tcount uint64,\n\tsum float64,\n\tbuckets map[float64]uint64,\n\tlabelValues ...string,\n) (Metric, error) {\n\tif desc.err != nil {\n\t\treturn nil, desc.err\n\t}\n\tif err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {\n\t\treturn nil, err\n\t}\n\treturn &constHistogram{\n\t\tdesc: desc,\n\t\tcount: count,\n\t\tsum: sum,\n\t\tbuckets: buckets,\n\t\tlabelPairs: MakeLabelPairs(desc, labelValues),\n\t}, nil\n}\n\n// MustNewConstHistogram is a version of NewConstHistogram that panics where\n// NewConstHistogram would have returned an error.\nfunc MustNewConstHistogram(\n\tdesc *Desc,\n\tcount uint64,\n\tsum float64,\n\tbuckets map[float64]uint64,\n\tlabelValues ...string,\n) Metric {\n\tm, err := NewConstHistogram(desc, count, sum, buckets, labelValues...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn m\n}\n\ntype buckSort []*dto.Bucket\n\nfunc (s buckSort) Len() int {\n\treturn len(s)\n}\n\nfunc (s buckSort) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc (s buckSort) Less(i, j int) bool {\n\treturn s[i].GetUpperBound() < s[j].GetUpperBound()\n}\n\n// pickSchema returns the largest number n between -4 and 8 such that\n// 2^(2^-n) is less or equal the provided bucketFactor.\n//\n// Special cases:\n// - bucketFactor <= 1: panics.\n// - bucketFactor < 2^(2^-8) (but > 1): still returns 8.\nfunc pickSchema(bucketFactor float64) int32 {\n\tif bucketFactor <= 1 {\n\t\tpanic(fmt.Errorf(\"bucketFactor %f is <=1\", bucketFactor))\n\t}\n\tfloor := math.Floor(math.Log2(math.Log2(bucketFactor)))\n\tswitch {\n\tcase floor <= -8:\n\t\treturn 8\n\tcase floor >= 4:\n\t\treturn -4\n\tdefault:\n\t\treturn -int32(floor)\n\t}\n}\n\nfunc makeBuckets(buckets *sync.Map) ([]*dto.BucketSpan, []int64) {\n\tvar ii []int\n\tbuckets.Range(func(k, v interface{}) bool {\n\t\tii = append(ii, k.(int))\n\t\treturn true\n\t})\n\tsort.Ints(ii)\n\n\tif len(ii) == 0 {\n\t\treturn nil, nil\n\t}\n\n\tvar (\n\t\tspans []*dto.BucketSpan\n\t\tdeltas []int64\n\t\tprevCount int64\n\t\tnextI int\n\t)\n\n\tappendDelta := func(count int64) {\n\t\t*spans[len(spans)-1].Length++\n\t\tdeltas = append(deltas, count-prevCount)\n\t\tprevCount = count\n\t}\n\n\tfor n, i := range ii {\n\t\tv, _ := buckets.Load(i)\n\t\tcount := atomic.LoadInt64(v.(*int64))\n\t\t// Multiple spans with only small gaps in between are probably\n\t\t// encoded more efficiently as one larger span with a few empty\n\t\t// buckets. Needs some research to find the sweet spot. For now,\n\t\t// we assume that gaps of one ore two buckets should not create\n\t\t// a new span.\n\t\tiDelta := int32(i - nextI)\n\t\tif n == 0 || iDelta > 2 {\n\t\t\t// We have to create a new span, either because we are\n\t\t\t// at the very beginning, or because we have found a gap\n\t\t\t// of more than two buckets.\n\t\t\tspans = append(spans, &dto.BucketSpan{\n\t\t\t\tOffset: proto.Int32(iDelta),\n\t\t\t\tLength: proto.Uint32(0),\n\t\t\t})\n\t\t} else {\n\t\t\t// We have found a small gap (or no gap at all).\n\t\t\t// Insert empty buckets as needed.\n\t\t\tfor j := int32(0); j < iDelta; j++ {\n\t\t\t\tappendDelta(0)\n\t\t\t}\n\t\t}\n\t\tappendDelta(count)\n\t\tnextI = i + 1\n\t}\n\treturn spans, deltas\n}\n\n// addToBucket increments the sparse bucket at key by the provided amount. It\n// returns true if a new sparse bucket had to be created for that.\nfunc addToBucket(buckets *sync.Map, key int, increment int64) bool {\n\tif existingBucket, ok := buckets.Load(key); ok {\n\t\t// Fast path without allocation.\n\t\tatomic.AddInt64(existingBucket.(*int64), increment)\n\t\treturn false\n\t}\n\t// Bucket doesn't exist yet. Slow path allocating new counter.\n\tnewBucket := increment // TODO(beorn7): Check if this is sufficient to not let increment escape.\n\tif actualBucket, loaded := buckets.LoadOrStore(key, &newBucket); loaded {\n\t\t// The bucket was created concurrently in another goroutine.\n\t\t// Have to increment after all.\n\t\tatomic.AddInt64(actualBucket.(*int64), increment)\n\t\treturn false\n\t}\n\treturn true\n}\n\n// addAndReset returns a function to be used with sync.Map.Range of spare\n// buckets in coldCounts. It increments the buckets in the provided hotBuckets\n// according to the buckets ranged through. It then resets all buckets ranged\n// through to 0 (but leaves them in place so that they don't need to get\n// recreated on the next scrape).\nfunc addAndReset(hotBuckets *sync.Map, bucketNumber *uint32) func(k, v interface{}) bool {\n\treturn func(k, v interface{}) bool {\n\t\tbucket := v.(*int64)\n\t\tif addToBucket(hotBuckets, k.(int), atomic.LoadInt64(bucket)) {\n\t\t\tatomic.AddUint32(bucketNumber, 1)\n\t\t}\n\t\tatomic.StoreInt64(bucket, 0)\n\t\treturn true\n\t}\n}\n\nfunc deleteSyncMap(m *sync.Map) {\n\tm.Range(func(k, v interface{}) bool {\n\t\tm.Delete(k)\n\t\treturn true\n\t})\n}\n\nfunc findSmallestKey(m *sync.Map) int {\n\tresult := math.MaxInt32\n\tm.Range(func(k, v interface{}) bool {\n\t\tkey := k.(int)\n\t\tif key < result {\n\t\t\tresult = key\n\t\t}\n\t\treturn true\n\t})\n\treturn result\n}\n\nfunc getLe(key int, schema int32) float64 {\n\t// Here a bit of context about the behavior for the last bucket counting\n\t// regular numbers (called simply \"last bucket\" below) and the bucket\n\t// counting observations of ±Inf (called \"inf bucket\" below, with a key\n\t// one higher than that of the \"last bucket\"):\n\t//\n\t// If we apply the usual formula to the last bucket, its upper bound\n\t// would be calculated as +Inf. The reason is that the max possible\n\t// regular float64 number (math.MaxFloat64) doesn't coincide with one of\n\t// the calculated bucket boundaries. So the calculated boundary has to\n\t// be larger than math.MaxFloat64, and the only float64 larger than\n\t// math.MaxFloat64 is +Inf. However, we want to count actual\n\t// observations of ±Inf in the inf bucket. Therefore, we have to treat\n\t// the upper bound of the last bucket specially and set it to\n\t// math.MaxFloat64. (The upper bound of the inf bucket, with its key\n\t// being one higher than that of the last bucket, naturally comes out as\n\t// +Inf by the usual formula. So that's fine.)\n\t//\n\t// math.MaxFloat64 has a frac of 0.9999999999999999 and an exp of\n\t// 1024. If there were a float64 number following math.MaxFloat64, it\n\t// would have a frac of 1.0 and an exp of 1024, or equivalently a frac\n\t// of 0.5 and an exp of 1025. However, since frac must be smaller than\n\t// 1, and exp must be smaller than 1025, either representation overflows\n\t// a float64. (Which, in turn, is the reason that math.MaxFloat64 is the\n\t// largest possible float64. Q.E.D.) However, the formula for\n\t// calculating the upper bound from the idx and schema of the last\n\t// bucket results in precisely that. It is either frac=1.0 & exp=1024\n\t// (for schema < 0) or frac=0.5 & exp=1025 (for schema >=0). (This is,\n\t// by the way, a power of two where the exponent itself is a power of\n\t// two, 2¹⁰ in fact, which coinicides with a bucket boundary in all\n\t// schemas.) So these are the special cases we have to catch below.\n\tif schema < 0 {\n\t\texp := key << -schema\n\t\tif exp == 1024 {\n\t\t\t// This is the last bucket before the overflow bucket\n\t\t\t// (for ±Inf observations). Return math.MaxFloat64 as\n\t\t\t// explained above.\n\t\t\treturn math.MaxFloat64\n\t\t}\n\t\treturn math.Ldexp(1, exp)\n\t}\n\n\tfracIdx := key & ((1 << schema) - 1)\n\tfrac := nativeHistogramBounds[schema][fracIdx]\n\texp := (key >> schema) + 1\n\tif frac == 0.5 && exp == 1025 {\n\t\t// This is the last bucket before the overflow bucket (for ±Inf\n\t\t// observations). Return math.MaxFloat64 as explained above.\n\t\treturn math.MaxFloat64\n\t}\n\treturn math.Ldexp(frac, exp)\n}\n\n// waitForCooldown returns after the count field in the provided histogramCounts\n// has reached the provided count value.\nfunc waitForCooldown(count uint64, counts *histogramCounts) {\n\tfor count != atomic.LoadUint64(&counts.count) {\n\t\truntime.Gosched() // Let observations get work done.\n\t}\n}\n\n// atomicAddFloat adds the provided float atomically to another float\n// represented by the bit pattern the bits pointer is pointing to.\nfunc atomicAddFloat(bits *uint64, v float64) {\n\tfor {\n\t\tloadedBits := atomic.LoadUint64(bits)\n\t\tnewBits := math.Float64bits(math.Float64frombits(loadedBits) + v)\n\t\tif atomic.CompareAndSwapUint64(bits, loadedBits, newBits) {\n\t\t\tbreak\n\t\t}\n\t}\n}\n\n// atomicDecUint32 atomically decrements the uint32 p points to. See\n// https://pkg.go.dev/sync/atomic#AddUint32 to understand how this is done.\nfunc atomicDecUint32(p *uint32) {\n\tatomic.AddUint32(p, ^uint32(0))\n}\n\n// addAndResetCounts adds certain fields (count, sum, conventional buckets, zero\n// bucket) from the cold counts to the corresponding fields in the hot\n// counts. Those fields are then reset to 0 in the cold counts.\nfunc addAndResetCounts(hot, cold *histogramCounts) {\n\tatomic.AddUint64(&hot.count, atomic.LoadUint64(&cold.count))\n\tatomic.StoreUint64(&cold.count, 0)\n\tcoldSum := math.Float64frombits(atomic.LoadUint64(&cold.sumBits))\n\tatomicAddFloat(&hot.sumBits, coldSum)\n\tatomic.StoreUint64(&cold.sumBits, 0)\n\tfor i := range hot.buckets {\n\t\tatomic.AddUint64(&hot.buckets[i], atomic.LoadUint64(&cold.buckets[i]))\n\t\tatomic.StoreUint64(&cold.buckets[i], 0)\n\t}\n\tatomic.AddUint64(&hot.nativeHistogramZeroBucket, atomic.LoadUint64(&cold.nativeHistogramZeroBucket))\n\tatomic.StoreUint64(&cold.nativeHistogramZeroBucket, 0)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/internal/almost_equal.go",
"content": "// Copyright (c) 2015 Björn Rabenstein\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n//\n// The code in this package is copy/paste to avoid a dependency. Hence this file\n// carries the copyright of the original repo.\n// https://github.com/beorn7/floats\npackage internal\n\nimport (\n\t\"math\"\n)\n\n// minNormalFloat64 is the smallest positive normal value of type float64.\nvar minNormalFloat64 = math.Float64frombits(0x0010000000000000)\n\n// AlmostEqualFloat64 returns true if a and b are equal within a relative error\n// of epsilon. See http://floating-point-gui.de/errors/comparison/ for the\n// details of the applied method.\nfunc AlmostEqualFloat64(a, b, epsilon float64) bool {\n\tif a == b {\n\t\treturn true\n\t}\n\tabsA := math.Abs(a)\n\tabsB := math.Abs(b)\n\tdiff := math.Abs(a - b)\n\tif a == 0 || b == 0 || absA+absB < minNormalFloat64 {\n\t\treturn diff < epsilon*minNormalFloat64\n\t}\n\treturn diff/math.Min(absA+absB, math.MaxFloat64) < epsilon\n}\n\n// AlmostEqualFloat64s is the slice form of AlmostEqualFloat64.\nfunc AlmostEqualFloat64s(a, b []float64, epsilon float64) bool {\n\tif len(a) != len(b) {\n\t\treturn false\n\t}\n\tfor i := range a {\n\t\tif !AlmostEqualFloat64(a[i], b[i], epsilon) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// It provides tools to compare sequences of strings and generate textual diffs.\n//\n// Maintaining `GetUnifiedDiffString` here because original repository\n// (https://github.com/pmezard/go-difflib) is no loger maintained.\npackage internal\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n)\n\nfunc min(a, b int) int {\n\tif a < b {\n\t\treturn a\n\t}\n\treturn b\n}\n\nfunc max(a, b int) int {\n\tif a > b {\n\t\treturn a\n\t}\n\treturn b\n}\n\nfunc calculateRatio(matches, length int) float64 {\n\tif length > 0 {\n\t\treturn 2.0 * float64(matches) / float64(length)\n\t}\n\treturn 1.0\n}\n\ntype Match struct {\n\tA int\n\tB int\n\tSize int\n}\n\ntype OpCode struct {\n\tTag byte\n\tI1 int\n\tI2 int\n\tJ1 int\n\tJ2 int\n}\n\n// SequenceMatcher compares sequence of strings. The basic\n// algorithm predates, and is a little fancier than, an algorithm\n// published in the late 1980's by Ratcliff and Obershelp under the\n// hyperbolic name \"gestalt pattern matching\". The basic idea is to find\n// the longest contiguous matching subsequence that contains no \"junk\"\n// elements (R-O doesn't address junk). The same idea is then applied\n// recursively to the pieces of the sequences to the left and to the right\n// of the matching subsequence. This does not yield minimal edit\n// sequences, but does tend to yield matches that \"look right\" to people.\n//\n// SequenceMatcher tries to compute a \"human-friendly diff\" between two\n// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the\n// longest *contiguous* & junk-free matching subsequence. That's what\n// catches peoples' eyes. The Windows(tm) windiff has another interesting\n// notion, pairing up elements that appear uniquely in each sequence.\n// That, and the method here, appear to yield more intuitive difference\n// reports than does diff. This method appears to be the least vulnerable\n// to synching up on blocks of \"junk lines\", though (like blank lines in\n// ordinary text files, or maybe \"\" lines in HTML files). That may be\n// because this is the only method of the 3 that has a *concept* of\n// \"junk\" .\n//\n// Timing: Basic R-O is cubic time worst case and quadratic time expected\n// case. SequenceMatcher is quadratic time for the worst case and has\n// expected-case behavior dependent in a complicated way on how many\n// elements the sequences have in common; best case time is linear.\ntype SequenceMatcher struct {\n\ta []string\n\tb []string\n\tb2j map[string][]int\n\tIsJunk func(string) bool\n\tautoJunk bool\n\tbJunk map[string]struct{}\n\tmatchingBlocks []Match\n\tfullBCount map[string]int\n\tbPopular map[string]struct{}\n\topCodes []OpCode\n}\n\nfunc NewMatcher(a, b []string) *SequenceMatcher {\n\tm := SequenceMatcher{autoJunk: true}\n\tm.SetSeqs(a, b)\n\treturn &m\n}\n\nfunc NewMatcherWithJunk(a, b []string, autoJunk bool,\n\tisJunk func(string) bool,\n) *SequenceMatcher {\n\tm := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}\n\tm.SetSeqs(a, b)\n\treturn &m\n}\n\n// Set two sequences to be compared.\nfunc (m *SequenceMatcher) SetSeqs(a, b []string) {\n\tm.SetSeq1(a)\n\tm.SetSeq2(b)\n}\n\n// Set the first sequence to be compared. The second sequence to be compared is\n// not changed.\n//\n// SequenceMatcher computes and caches detailed information about the second\n// sequence, so if you want to compare one sequence S against many sequences,\n// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other\n// sequences.\n//\n// See also SetSeqs() and SetSeq2().\nfunc (m *SequenceMatcher) SetSeq1(a []string) {\n\tif &a == &m.a {\n\t\treturn\n\t}\n\tm.a = a\n\tm.matchingBlocks = nil\n\tm.opCodes = nil\n}\n\n// Set the second sequence to be compared. The first sequence to be compared is\n// not changed.\nfunc (m *SequenceMatcher) SetSeq2(b []string) {\n\tif &b == &m.b {\n\t\treturn\n\t}\n\tm.b = b\n\tm.matchingBlocks = nil\n\tm.opCodes = nil\n\tm.fullBCount = nil\n\tm.chainB()\n}\n\nfunc (m *SequenceMatcher) chainB() {\n\t// Populate line -> index mapping\n\tb2j := map[string][]int{}\n\tfor i, s := range m.b {\n\t\tindices := b2j[s]\n\t\tindices = append(indices, i)\n\t\tb2j[s] = indices\n\t}\n\n\t// Purge junk elements\n\tm.bJunk = map[string]struct{}{}\n\tif m.IsJunk != nil {\n\t\tjunk := m.bJunk\n\t\tfor s := range b2j {\n\t\t\tif m.IsJunk(s) {\n\t\t\t\tjunk[s] = struct{}{}\n\t\t\t}\n\t\t}\n\t\tfor s := range junk {\n\t\t\tdelete(b2j, s)\n\t\t}\n\t}\n\n\t// Purge remaining popular elements\n\tpopular := map[string]struct{}{}\n\tn := len(m.b)\n\tif m.autoJunk && n >= 200 {\n\t\tntest := n/100 + 1\n\t\tfor s, indices := range b2j {\n\t\t\tif len(indices) > ntest {\n\t\t\t\tpopular[s] = struct{}{}\n\t\t\t}\n\t\t}\n\t\tfor s := range popular {\n\t\t\tdelete(b2j, s)\n\t\t}\n\t}\n\tm.bPopular = popular\n\tm.b2j = b2j\n}\n\nfunc (m *SequenceMatcher) isBJunk(s string) bool {\n\t_, ok := m.bJunk[s]\n\treturn ok\n}\n\n// Find longest matching block in a[alo:ahi] and b[blo:bhi].\n//\n// If IsJunk is not defined:\n//\n// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where\n//\n//\talo <= i <= i+k <= ahi\n//\tblo <= j <= j+k <= bhi\n//\n// and for all (i',j',k') meeting those conditions,\n//\n//\tk >= k'\n//\ti <= i'\n//\tand if i == i', j <= j'\n//\n// In other words, of all maximal matching blocks, return one that\n// starts earliest in a, and of all those maximal matching blocks that\n// start earliest in a, return the one that starts earliest in b.\n//\n// If IsJunk is defined, first the longest matching block is\n// determined as above, but with the additional restriction that no\n// junk element appears in the block. Then that block is extended as\n// far as possible by matching (only) junk elements on both sides. So\n// the resulting block never matches on junk except as identical junk\n// happens to be adjacent to an \"interesting\" match.\n//\n// If no blocks match, return (alo, blo, 0).\nfunc (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {\n\t// CAUTION: stripping common prefix or suffix would be incorrect.\n\t// E.g.,\n\t// ab\n\t// acab\n\t// Longest matching block is \"ab\", but if common prefix is\n\t// stripped, it's \"a\" (tied with \"b\"). UNIX(tm) diff does so\n\t// strip, so ends up claiming that ab is changed to acab by\n\t// inserting \"ca\" in the middle. That's minimal but unintuitive:\n\t// \"it's obvious\" that someone inserted \"ac\" at the front.\n\t// Windiff ends up at the same place as diff, but by pairing up\n\t// the unique 'b's and then matching the first two 'a's.\n\tbesti, bestj, bestsize := alo, blo, 0\n\n\t// find longest junk-free match\n\t// during an iteration of the loop, j2len[j] = length of longest\n\t// junk-free match ending with a[i-1] and b[j]\n\tj2len := map[int]int{}\n\tfor i := alo; i != ahi; i++ {\n\t\t// look at all instances of a[i] in b; note that because\n\t\t// b2j has no junk keys, the loop is skipped if a[i] is junk\n\t\tnewj2len := map[int]int{}\n\t\tfor _, j := range m.b2j[m.a[i]] {\n\t\t\t// a[i] matches b[j]\n\t\t\tif j < blo {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif j >= bhi {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tk := j2len[j-1] + 1\n\t\t\tnewj2len[j] = k\n\t\t\tif k > bestsize {\n\t\t\t\tbesti, bestj, bestsize = i-k+1, j-k+1, k\n\t\t\t}\n\t\t}\n\t\tj2len = newj2len\n\t}\n\n\t// Extend the best by non-junk elements on each end. In particular,\n\t// \"popular\" non-junk elements aren't in b2j, which greatly speeds\n\t// the inner loop above, but also means \"the best\" match so far\n\t// doesn't contain any junk *or* popular non-junk elements.\n\tfor besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&\n\t\tm.a[besti-1] == m.b[bestj-1] {\n\t\tbesti, bestj, bestsize = besti-1, bestj-1, bestsize+1\n\t}\n\tfor besti+bestsize < ahi && bestj+bestsize < bhi &&\n\t\t!m.isBJunk(m.b[bestj+bestsize]) &&\n\t\tm.a[besti+bestsize] == m.b[bestj+bestsize] {\n\t\tbestsize++\n\t}\n\n\t// Now that we have a wholly interesting match (albeit possibly\n\t// empty!), we may as well suck up the matching junk on each\n\t// side of it too. Can't think of a good reason not to, and it\n\t// saves post-processing the (possibly considerable) expense of\n\t// figuring out what to do with it. In the case of an empty\n\t// interesting match, this is clearly the right thing to do,\n\t// because no other kind of match is possible in the regions.\n\tfor besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&\n\t\tm.a[besti-1] == m.b[bestj-1] {\n\t\tbesti, bestj, bestsize = besti-1, bestj-1, bestsize+1\n\t}\n\tfor besti+bestsize < ahi && bestj+bestsize < bhi &&\n\t\tm.isBJunk(m.b[bestj+bestsize]) &&\n\t\tm.a[besti+bestsize] == m.b[bestj+bestsize] {\n\t\tbestsize++\n\t}\n\n\treturn Match{A: besti, B: bestj, Size: bestsize}\n}\n\n// Return list of triples describing matching subsequences.\n//\n// Each triple is of the form (i, j, n), and means that\n// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in\n// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are\n// adjacent triples in the list, and the second is not the last triple in the\n// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe\n// adjacent equal blocks.\n//\n// The last triple is a dummy, (len(a), len(b), 0), and is the only\n// triple with n==0.\nfunc (m *SequenceMatcher) GetMatchingBlocks() []Match {\n\tif m.matchingBlocks != nil {\n\t\treturn m.matchingBlocks\n\t}\n\n\tvar matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match\n\tmatchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {\n\t\tmatch := m.findLongestMatch(alo, ahi, blo, bhi)\n\t\ti, j, k := match.A, match.B, match.Size\n\t\tif match.Size > 0 {\n\t\t\tif alo < i && blo < j {\n\t\t\t\tmatched = matchBlocks(alo, i, blo, j, matched)\n\t\t\t}\n\t\t\tmatched = append(matched, match)\n\t\t\tif i+k < ahi && j+k < bhi {\n\t\t\t\tmatched = matchBlocks(i+k, ahi, j+k, bhi, matched)\n\t\t\t}\n\t\t}\n\t\treturn matched\n\t}\n\tmatched := matchBlocks(0, len(m.a), 0, len(m.b), nil)\n\n\t// It's possible that we have adjacent equal blocks in the\n\t// matching_blocks list now.\n\tnonAdjacent := []Match{}\n\ti1, j1, k1 := 0, 0, 0\n\tfor _, b := range matched {\n\t\t// Is this block adjacent to i1, j1, k1?\n\t\ti2, j2, k2 := b.A, b.B, b.Size\n\t\tif i1+k1 == i2 && j1+k1 == j2 {\n\t\t\t// Yes, so collapse them -- this just increases the length of\n\t\t\t// the first block by the length of the second, and the first\n\t\t\t// block so lengthened remains the block to compare against.\n\t\t\tk1 += k2\n\t\t} else {\n\t\t\t// Not adjacent. Remember the first block (k1==0 means it's\n\t\t\t// the dummy we started with), and make the second block the\n\t\t\t// new block to compare against.\n\t\t\tif k1 > 0 {\n\t\t\t\tnonAdjacent = append(nonAdjacent, Match{i1, j1, k1})\n\t\t\t}\n\t\t\ti1, j1, k1 = i2, j2, k2\n\t\t}\n\t}\n\tif k1 > 0 {\n\t\tnonAdjacent = append(nonAdjacent, Match{i1, j1, k1})\n\t}\n\n\tnonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})\n\tm.matchingBlocks = nonAdjacent\n\treturn m.matchingBlocks\n}\n\n// Return list of 5-tuples describing how to turn a into b.\n//\n// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple\n// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the\n// tuple preceding it, and likewise for j1 == the previous j2.\n//\n// The tags are characters, with these meanings:\n//\n// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]\n//\n// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.\n//\n// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.\n//\n// 'e' (equal): a[i1:i2] == b[j1:j2]\nfunc (m *SequenceMatcher) GetOpCodes() []OpCode {\n\tif m.opCodes != nil {\n\t\treturn m.opCodes\n\t}\n\ti, j := 0, 0\n\tmatching := m.GetMatchingBlocks()\n\topCodes := make([]OpCode, 0, len(matching))\n\tfor _, m := range matching {\n\t\t// invariant: we've pumped out correct diffs to change\n\t\t// a[:i] into b[:j], and the next matching block is\n\t\t// a[ai:ai+size] == b[bj:bj+size]. So we need to pump\n\t\t// out a diff to change a[i:ai] into b[j:bj], pump out\n\t\t// the matching block, and move (i,j) beyond the match\n\t\tai, bj, size := m.A, m.B, m.Size\n\t\ttag := byte(0)\n\t\tif i < ai && j < bj {\n\t\t\ttag = 'r'\n\t\t} else if i < ai {\n\t\t\ttag = 'd'\n\t\t} else if j < bj {\n\t\t\ttag = 'i'\n\t\t}\n\t\tif tag > 0 {\n\t\t\topCodes = append(opCodes, OpCode{tag, i, ai, j, bj})\n\t\t}\n\t\ti, j = ai+size, bj+size\n\t\t// the list of matching blocks is terminated by a\n\t\t// sentinel with size 0\n\t\tif size > 0 {\n\t\t\topCodes = append(opCodes, OpCode{'e', ai, i, bj, j})\n\t\t}\n\t}\n\tm.opCodes = opCodes\n\treturn m.opCodes\n}\n\n// Isolate change clusters by eliminating ranges with no changes.\n//\n// Return a generator of groups with up to n lines of context.\n// Each group is in the same format as returned by GetOpCodes().\nfunc (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {\n\tif n < 0 {\n\t\tn = 3\n\t}\n\tcodes := m.GetOpCodes()\n\tif len(codes) == 0 {\n\t\tcodes = []OpCode{{'e', 0, 1, 0, 1}}\n\t}\n\t// Fixup leading and trailing groups if they show no changes.\n\tif codes[0].Tag == 'e' {\n\t\tc := codes[0]\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\tcodes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}\n\t}\n\tif codes[len(codes)-1].Tag == 'e' {\n\t\tc := codes[len(codes)-1]\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\tcodes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}\n\t}\n\tnn := n + n\n\tgroups := [][]OpCode{}\n\tgroup := []OpCode{}\n\tfor _, c := range codes {\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\t// End the current group and start a new one whenever\n\t\t// there is a large range with no changes.\n\t\tif c.Tag == 'e' && i2-i1 > nn {\n\t\t\tgroup = append(group, OpCode{\n\t\t\t\tc.Tag, i1, min(i2, i1+n),\n\t\t\t\tj1, min(j2, j1+n),\n\t\t\t})\n\t\t\tgroups = append(groups, group)\n\t\t\tgroup = []OpCode{}\n\t\t\ti1, j1 = max(i1, i2-n), max(j1, j2-n)\n\t\t}\n\t\tgroup = append(group, OpCode{c.Tag, i1, i2, j1, j2})\n\t}\n\tif len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {\n\t\tgroups = append(groups, group)\n\t}\n\treturn groups\n}\n\n// Return a measure of the sequences' similarity (float in [0,1]).\n//\n// Where T is the total number of elements in both sequences, and\n// M is the number of matches, this is 2.0*M / T.\n// Note that this is 1 if the sequences are identical, and 0 if\n// they have nothing in common.\n//\n// .Ratio() is expensive to compute if you haven't already computed\n// .GetMatchingBlocks() or .GetOpCodes(), in which case you may\n// want to try .QuickRatio() or .RealQuickRation() first to get an\n// upper bound.\nfunc (m *SequenceMatcher) Ratio() float64 {\n\tmatches := 0\n\tfor _, m := range m.GetMatchingBlocks() {\n\t\tmatches += m.Size\n\t}\n\treturn calculateRatio(matches, len(m.a)+len(m.b))\n}\n\n// Return an upper bound on ratio() relatively quickly.\n//\n// This isn't defined beyond that it is an upper bound on .Ratio(), and\n// is faster to compute.\nfunc (m *SequenceMatcher) QuickRatio() float64 {\n\t// viewing a and b as multisets, set matches to the cardinality\n\t// of their intersection; this counts the number of matches\n\t// without regard to order, so is clearly an upper bound\n\tif m.fullBCount == nil {\n\t\tm.fullBCount = map[string]int{}\n\t\tfor _, s := range m.b {\n\t\t\tm.fullBCount[s]++\n\t\t}\n\t}\n\n\t// avail[x] is the number of times x appears in 'b' less the\n\t// number of times we've seen it in 'a' so far ... kinda\n\tavail := map[string]int{}\n\tmatches := 0\n\tfor _, s := range m.a {\n\t\tn, ok := avail[s]\n\t\tif !ok {\n\t\t\tn = m.fullBCount[s]\n\t\t}\n\t\tavail[s] = n - 1\n\t\tif n > 0 {\n\t\t\tmatches++\n\t\t}\n\t}\n\treturn calculateRatio(matches, len(m.a)+len(m.b))\n}\n\n// Return an upper bound on ratio() very quickly.\n//\n// This isn't defined beyond that it is an upper bound on .Ratio(), and\n// is faster to compute than either .Ratio() or .QuickRatio().\nfunc (m *SequenceMatcher) RealQuickRatio() float64 {\n\tla, lb := len(m.a), len(m.b)\n\treturn calculateRatio(min(la, lb), la+lb)\n}\n\n// Convert range to the \"ed\" format\nfunc formatRangeUnified(start, stop int) string {\n\t// Per the diff spec at http://www.unix.org/single_unix_specification/\n\tbeginning := start + 1 // lines start numbering with one\n\tlength := stop - start\n\tif length == 1 {\n\t\treturn fmt.Sprintf(\"%d\", beginning)\n\t}\n\tif length == 0 {\n\t\tbeginning-- // empty ranges begin at line just before the range\n\t}\n\treturn fmt.Sprintf(\"%d,%d\", beginning, length)\n}\n\n// Unified diff parameters\ntype UnifiedDiff struct {\n\tA []string // First sequence lines\n\tFromFile string // First file name\n\tFromDate string // First file time\n\tB []string // Second sequence lines\n\tToFile string // Second file name\n\tToDate string // Second file time\n\tEol string // Headers end of line, defaults to LF\n\tContext int // Number of context lines\n}\n\n// Compare two sequences of lines; generate the delta as a unified diff.\n//\n// Unified diffs are a compact way of showing line changes and a few\n// lines of context. The number of context lines is set by 'n' which\n// defaults to three.\n//\n// By default, the diff control lines (those with ---, +++, or @@) are\n// created with a trailing newline. This is helpful so that inputs\n// created from file.readlines() result in diffs that are suitable for\n// file.writelines() since both the inputs and outputs have trailing\n// newlines.\n//\n// For inputs that do not have trailing newlines, set the lineterm\n// argument to \"\" so that the output will be uniformly newline free.\n//\n// The unidiff format normally has a header for filenames and modification\n// times. Any or all of these may be specified using strings for\n// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.\n// The modification times are normally expressed in the ISO 8601 format.\nfunc WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {\n\tbuf := bufio.NewWriter(writer)\n\tdefer buf.Flush()\n\twf := func(format string, args ...interface{}) error {\n\t\t_, err := buf.WriteString(fmt.Sprintf(format, args...))\n\t\treturn err\n\t}\n\tws := func(s string) error {\n\t\t_, err := buf.WriteString(s)\n\t\treturn err\n\t}\n\n\tif len(diff.Eol) == 0 {\n\t\tdiff.Eol = \"\\n\"\n\t}\n\n\tstarted := false\n\tm := NewMatcher(diff.A, diff.B)\n\tfor _, g := range m.GetGroupedOpCodes(diff.Context) {\n\t\tif !started {\n\t\t\tstarted = true\n\t\t\tfromDate := \"\"\n\t\t\tif len(diff.FromDate) > 0 {\n\t\t\t\tfromDate = \"\\t\" + diff.FromDate\n\t\t\t}\n\t\t\ttoDate := \"\"\n\t\t\tif len(diff.ToDate) > 0 {\n\t\t\t\ttoDate = \"\\t\" + diff.ToDate\n\t\t\t}\n\t\t\tif diff.FromFile != \"\" || diff.ToFile != \"\" {\n\t\t\t\terr := wf(\"--- %s%s%s\", diff.FromFile, fromDate, diff.Eol)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\terr = wf(\"+++ %s%s%s\", diff.ToFile, toDate, diff.Eol)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfirst, last := g[0], g[len(g)-1]\n\t\trange1 := formatRangeUnified(first.I1, last.I2)\n\t\trange2 := formatRangeUnified(first.J1, last.J2)\n\t\tif err := wf(\"@@ -%s +%s @@%s\", range1, range2, diff.Eol); err != nil {\n\t\t\treturn err\n\t\t}\n\t\tfor _, c := range g {\n\t\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\t\tif c.Tag == 'e' {\n\t\t\t\tfor _, line := range diff.A[i1:i2] {\n\t\t\t\t\tif err := ws(\" \" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif c.Tag == 'r' || c.Tag == 'd' {\n\t\t\t\tfor _, line := range diff.A[i1:i2] {\n\t\t\t\t\tif err := ws(\"-\" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif c.Tag == 'r' || c.Tag == 'i' {\n\t\t\t\tfor _, line := range diff.B[j1:j2] {\n\t\t\t\t\tif err := ws(\"+\" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn nil\n}\n\n// Like WriteUnifiedDiff but returns the diff a string.\nfunc GetUnifiedDiffString(diff UnifiedDiff) (string, error) {\n\tw := &bytes.Buffer{}\n\terr := WriteUnifiedDiff(w, diff)\n\treturn w.String(), err\n}\n\n// Split a string on \"\\n\" while preserving them. The output can be used\n// as input for UnifiedDiff and ContextDiff structures.\nfunc SplitLines(s string) []string {\n\tlines := strings.SplitAfter(s, \"\\n\")\n\tlines[len(lines)-1] += \"\\n\"\n\treturn lines\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/internal/go_collector_options.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage internal\n\nimport \"regexp\"\n\ntype GoCollectorRule struct {\n\tMatcher *regexp.Regexp\n\tDeny bool\n}\n\n// GoCollectorOptions should not be used be directly by anything, except `collectors` package.\n// Use it via collectors package instead. See issue\n// https://github.com/prometheus/client_golang/issues/1030.\n//\n// This is internal, so external users only can use it via `collector.WithGoCollector*` methods\ntype GoCollectorOptions struct {\n\tDisableMemStatsLikeMetrics bool\n\tRuntimeMetricSumForHist map[string]string\n\tRuntimeMetricRules []GoCollectorRule\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/internal/go_runtime_metrics.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build go1.17\n// +build go1.17\n\npackage internal\n\nimport (\n\t\"math\"\n\t\"path\"\n\t\"runtime/metrics\"\n\t\"strings\"\n\n\t\"github.com/prometheus/common/model\"\n)\n\n// RuntimeMetricsToProm produces a Prometheus metric name from a runtime/metrics\n// metric description and validates whether the metric is suitable for integration\n// with Prometheus.\n//\n// Returns false if a name could not be produced, or if Prometheus does not understand\n// the runtime/metrics Kind.\n//\n// Note that the main reason a name couldn't be produced is if the runtime/metrics\n// package exports a name with characters outside the valid Prometheus metric name\n// character set. This is theoretically possible, but should never happen in practice.\n// Still, don't rely on it.\nfunc RuntimeMetricsToProm(d *metrics.Description) (string, string, string, bool) {\n\tnamespace := \"go\"\n\n\tcomp := strings.SplitN(d.Name, \":\", 2)\n\tkey := comp[0]\n\tunit := comp[1]\n\n\t// The last path element in the key is the name,\n\t// the rest is the subsystem.\n\tsubsystem := path.Dir(key[1:] /* remove leading / */)\n\tname := path.Base(key)\n\n\t// subsystem is translated by replacing all / and - with _.\n\tsubsystem = strings.ReplaceAll(subsystem, \"/\", \"_\")\n\tsubsystem = strings.ReplaceAll(subsystem, \"-\", \"_\")\n\n\t// unit is translated assuming that the unit contains no\n\t// non-ASCII characters.\n\tunit = strings.ReplaceAll(unit, \"-\", \"_\")\n\tunit = strings.ReplaceAll(unit, \"*\", \"_\")\n\tunit = strings.ReplaceAll(unit, \"/\", \"_per_\")\n\n\t// name has - replaced with _ and is concatenated with the unit and\n\t// other data.\n\tname = strings.ReplaceAll(name, \"-\", \"_\")\n\tname += \"_\" + unit\n\tif d.Cumulative && d.Kind != metrics.KindFloat64Histogram {\n\t\tname += \"_total\"\n\t}\n\n\tvalid := model.IsValidMetricName(model.LabelValue(namespace + \"_\" + subsystem + \"_\" + name))\n\tswitch d.Kind {\n\tcase metrics.KindUint64:\n\tcase metrics.KindFloat64:\n\tcase metrics.KindFloat64Histogram:\n\tdefault:\n\t\tvalid = false\n\t}\n\treturn namespace, subsystem, name, valid\n}\n\n// RuntimeMetricsBucketsForUnit takes a set of buckets obtained for a runtime/metrics histogram\n// type (so, lower-bound inclusive) and a unit from a runtime/metrics name, and produces\n// a reduced set of buckets. This function always removes any -Inf bucket as it's represented\n// as the bottom-most upper-bound inclusive bucket in Prometheus.\nfunc RuntimeMetricsBucketsForUnit(buckets []float64, unit string) []float64 {\n\tswitch unit {\n\tcase \"bytes\":\n\t\t// Re-bucket as powers of 2.\n\t\treturn reBucketExp(buckets, 2)\n\tcase \"seconds\":\n\t\t// Re-bucket as powers of 10 and then merge all buckets greater\n\t\t// than 1 second into the +Inf bucket.\n\t\tb := reBucketExp(buckets, 10)\n\t\tfor i := range b {\n\t\t\tif b[i] <= 1 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tb[i] = math.Inf(1)\n\t\t\tb = b[:i+1]\n\t\t\tbreak\n\t\t}\n\t\treturn b\n\t}\n\treturn buckets\n}\n\n// reBucketExp takes a list of bucket boundaries (lower bound inclusive) and\n// downsamples the buckets to those a multiple of base apart. The end result\n// is a roughly exponential (in many cases, perfectly exponential) bucketing\n// scheme.\nfunc reBucketExp(buckets []float64, base float64) []float64 {\n\tbucket := buckets[0]\n\tvar newBuckets []float64\n\t// We may see a -Inf here, in which case, add it and skip it\n\t// since we risk producing NaNs otherwise.\n\t//\n\t// We need to preserve -Inf values to maintain runtime/metrics\n\t// conventions. We'll strip it out later.\n\tif bucket == math.Inf(-1) {\n\t\tnewBuckets = append(newBuckets, bucket)\n\t\tbuckets = buckets[1:]\n\t\tbucket = buckets[0]\n\t}\n\t// From now on, bucket should always have a non-Inf value because\n\t// Infs are only ever at the ends of the bucket lists, so\n\t// arithmetic operations on it are non-NaN.\n\tfor i := 1; i < len(buckets); i++ {\n\t\tif bucket >= 0 && buckets[i] < bucket*base {\n\t\t\t// The next bucket we want to include is at least bucket*base.\n\t\t\tcontinue\n\t\t} else if bucket < 0 && buckets[i] < bucket/base {\n\t\t\t// In this case the bucket we're targeting is negative, and since\n\t\t\t// we're ascending through buckets here, we need to divide to get\n\t\t\t// closer to zero exponentially.\n\t\t\tcontinue\n\t\t}\n\t\t// The +Inf bucket will always be the last one, and we'll always\n\t\t// end up including it here because bucket\n\t\tnewBuckets = append(newBuckets, bucket)\n\t\tbucket = buckets[i]\n\t}\n\treturn append(newBuckets, bucket)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/internal/metric.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage internal\n\nimport (\n\t\"sort\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// LabelPairSorter implements sort.Interface. It is used to sort a slice of\n// dto.LabelPair pointers.\ntype LabelPairSorter []*dto.LabelPair\n\nfunc (s LabelPairSorter) Len() int {\n\treturn len(s)\n}\n\nfunc (s LabelPairSorter) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc (s LabelPairSorter) Less(i, j int) bool {\n\treturn s[i].GetName() < s[j].GetName()\n}\n\n// MetricSorter is a sortable slice of *dto.Metric.\ntype MetricSorter []*dto.Metric\n\nfunc (s MetricSorter) Len() int {\n\treturn len(s)\n}\n\nfunc (s MetricSorter) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc (s MetricSorter) Less(i, j int) bool {\n\tif len(s[i].Label) != len(s[j].Label) {\n\t\t// This should not happen. The metrics are\n\t\t// inconsistent. However, we have to deal with the fact, as\n\t\t// people might use custom collectors or metric family injection\n\t\t// to create inconsistent metrics. So let's simply compare the\n\t\t// number of labels in this case. That will still yield\n\t\t// reproducible sorting.\n\t\treturn len(s[i].Label) < len(s[j].Label)\n\t}\n\tfor n, lp := range s[i].Label {\n\t\tvi := lp.GetValue()\n\t\tvj := s[j].Label[n].GetValue()\n\t\tif vi != vj {\n\t\t\treturn vi < vj\n\t\t}\n\t}\n\n\t// We should never arrive here. Multiple metrics with the same\n\t// label set in the same scrape will lead to undefined ingestion\n\t// behavior. However, as above, we have to provide stable sorting\n\t// here, even for inconsistent metrics. So sort equal metrics\n\t// by their timestamp, with missing timestamps (implying \"now\")\n\t// coming last.\n\tif s[i].TimestampMs == nil {\n\t\treturn false\n\t}\n\tif s[j].TimestampMs == nil {\n\t\treturn true\n\t}\n\treturn s[i].GetTimestampMs() < s[j].GetTimestampMs()\n}\n\n// NormalizeMetricFamilies returns a MetricFamily slice with empty\n// MetricFamilies pruned and the remaining MetricFamilies sorted by name within\n// the slice, with the contained Metrics sorted within each MetricFamily.\nfunc NormalizeMetricFamilies(metricFamiliesByName map[string]*dto.MetricFamily) []*dto.MetricFamily {\n\tfor _, mf := range metricFamiliesByName {\n\t\tsort.Sort(MetricSorter(mf.Metric))\n\t}\n\tnames := make([]string, 0, len(metricFamiliesByName))\n\tfor name, mf := range metricFamiliesByName {\n\t\tif len(mf.Metric) > 0 {\n\t\t\tnames = append(names, name)\n\t\t}\n\t}\n\tsort.Strings(names)\n\tresult := make([]*dto.MetricFamily, 0, len(names))\n\tfor _, name := range names {\n\t\tresult = append(result, metricFamiliesByName[name])\n\t}\n\treturn result\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/labels.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"strings\"\n\t\"unicode/utf8\"\n\n\t\"github.com/prometheus/common/model\"\n)\n\n// Labels represents a collection of label name -> value mappings. This type is\n// commonly used with the With(Labels) and GetMetricWith(Labels) methods of\n// metric vector Collectors, e.g.:\n//\n//\tmyVec.With(Labels{\"code\": \"404\", \"method\": \"GET\"}).Add(42)\n//\n// The other use-case is the specification of constant label pairs in Opts or to\n// create a Desc.\ntype Labels map[string]string\n\n// reservedLabelPrefix is a prefix which is not legal in user-supplied\n// label names.\nconst reservedLabelPrefix = \"__\"\n\nvar errInconsistentCardinality = errors.New(\"inconsistent label cardinality\")\n\nfunc makeInconsistentCardinalityError(fqName string, labels, labelValues []string) error {\n\treturn fmt.Errorf(\n\t\t\"%w: %q has %d variable labels named %q but %d values %q were provided\",\n\t\terrInconsistentCardinality, fqName,\n\t\tlen(labels), labels,\n\t\tlen(labelValues), labelValues,\n\t)\n}\n\nfunc validateValuesInLabels(labels Labels, expectedNumberOfValues int) error {\n\tif len(labels) != expectedNumberOfValues {\n\t\treturn fmt.Errorf(\n\t\t\t\"%w: expected %d label values but got %d in %#v\",\n\t\t\terrInconsistentCardinality, expectedNumberOfValues,\n\t\t\tlen(labels), labels,\n\t\t)\n\t}\n\n\tfor name, val := range labels {\n\t\tif !utf8.ValidString(val) {\n\t\t\treturn fmt.Errorf(\"label %s: value %q is not valid UTF-8\", name, val)\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc validateLabelValues(vals []string, expectedNumberOfValues int) error {\n\tif len(vals) != expectedNumberOfValues {\n\t\treturn fmt.Errorf(\n\t\t\t\"%w: expected %d label values but got %d in %#v\",\n\t\t\terrInconsistentCardinality, expectedNumberOfValues,\n\t\t\tlen(vals), vals,\n\t\t)\n\t}\n\n\tfor _, val := range vals {\n\t\tif !utf8.ValidString(val) {\n\t\t\treturn fmt.Errorf(\"label value %q is not valid UTF-8\", val)\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc checkLabelName(l string) bool {\n\treturn model.LabelName(l).IsValid() && !strings.HasPrefix(l, reservedLabelPrefix)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/metric.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"errors\"\n\t\"math\"\n\t\"sort\"\n\t\"strings\"\n\t\"time\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\t\"github.com/prometheus/common/model\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\nvar separatorByteSlice = []byte{model.SeparatorByte} // For convenient use with xxhash.\n\n// A Metric models a single sample value with its meta data being exported to\n// Prometheus. Implementations of Metric in this package are Gauge, Counter,\n// Histogram, Summary, and Untyped.\ntype Metric interface {\n\t// Desc returns the descriptor for the Metric. This method idempotently\n\t// returns the same descriptor throughout the lifetime of the\n\t// Metric. The returned descriptor is immutable by contract. A Metric\n\t// unable to describe itself must return an invalid descriptor (created\n\t// with NewInvalidDesc).\n\tDesc() *Desc\n\t// Write encodes the Metric into a \"Metric\" Protocol Buffer data\n\t// transmission object.\n\t//\n\t// Metric implementations must observe concurrency safety as reads of\n\t// this metric may occur at any time, and any blocking occurs at the\n\t// expense of total performance of rendering all registered\n\t// metrics. Ideally, Metric implementations should support concurrent\n\t// readers.\n\t//\n\t// While populating dto.Metric, it is the responsibility of the\n\t// implementation to ensure validity of the Metric protobuf (like valid\n\t// UTF-8 strings or syntactically valid metric and label names). It is\n\t// recommended to sort labels lexicographically. Callers of Write should\n\t// still make sure of sorting if they depend on it.\n\tWrite(*dto.Metric) error\n\t// TODO(beorn7): The original rationale of passing in a pre-allocated\n\t// dto.Metric protobuf to save allocations has disappeared. The\n\t// signature of this method should be changed to \"Write() (*dto.Metric,\n\t// error)\".\n}\n\n// Opts bundles the options for creating most Metric types. Each metric\n// implementation XXX has its own XXXOpts type, but in most cases, it is just\n// an alias of this type (which might change when the requirement arises.)\n//\n// It is mandatory to set Name to a non-empty string. All other fields are\n// optional and can safely be left at their zero value, although it is strongly\n// encouraged to set a Help string.\ntype Opts struct {\n\t// Namespace, Subsystem, and Name are components of the fully-qualified\n\t// name of the Metric (created by joining these components with\n\t// \"_\"). Only Name is mandatory, the others merely help structuring the\n\t// name. Note that the fully-qualified name of the metric must be a\n\t// valid Prometheus metric name.\n\tNamespace string\n\tSubsystem string\n\tName string\n\n\t// Help provides information about this metric.\n\t//\n\t// Metrics with the same fully-qualified name must have the same Help\n\t// string.\n\tHelp string\n\n\t// ConstLabels are used to attach fixed labels to this metric. Metrics\n\t// with the same fully-qualified name must have the same label names in\n\t// their ConstLabels.\n\t//\n\t// ConstLabels are only used rarely. In particular, do not use them to\n\t// attach the same labels to all your metrics. Those use cases are\n\t// better covered by target labels set by the scraping Prometheus\n\t// server, or by one specific metric (e.g. a build_info or a\n\t// machine_role metric). See also\n\t// https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels\n\tConstLabels Labels\n}\n\n// BuildFQName joins the given three name components by \"_\". Empty name\n// components are ignored. If the name parameter itself is empty, an empty\n// string is returned, no matter what. Metric implementations included in this\n// library use this function internally to generate the fully-qualified metric\n// name from the name component in their Opts. Users of the library will only\n// need this function if they implement their own Metric or instantiate a Desc\n// (with NewDesc) directly.\nfunc BuildFQName(namespace, subsystem, name string) string {\n\tif name == \"\" {\n\t\treturn \"\"\n\t}\n\tswitch {\n\tcase namespace != \"\" && subsystem != \"\":\n\t\treturn strings.Join([]string{namespace, subsystem, name}, \"_\")\n\tcase namespace != \"\":\n\t\treturn strings.Join([]string{namespace, name}, \"_\")\n\tcase subsystem != \"\":\n\t\treturn strings.Join([]string{subsystem, name}, \"_\")\n\t}\n\treturn name\n}\n\ntype invalidMetric struct {\n\tdesc *Desc\n\terr error\n}\n\n// NewInvalidMetric returns a metric whose Write method always returns the\n// provided error. It is useful if a Collector finds itself unable to collect\n// a metric and wishes to report an error to the registry.\nfunc NewInvalidMetric(desc *Desc, err error) Metric {\n\treturn &invalidMetric{desc, err}\n}\n\nfunc (m *invalidMetric) Desc() *Desc { return m.desc }\n\nfunc (m *invalidMetric) Write(*dto.Metric) error { return m.err }\n\ntype timestampedMetric struct {\n\tMetric\n\tt time.Time\n}\n\nfunc (m timestampedMetric) Write(pb *dto.Metric) error {\n\te := m.Metric.Write(pb)\n\tpb.TimestampMs = proto.Int64(m.t.Unix()*1000 + int64(m.t.Nanosecond()/1000000))\n\treturn e\n}\n\n// NewMetricWithTimestamp returns a new Metric wrapping the provided Metric in a\n// way that it has an explicit timestamp set to the provided Time. This is only\n// useful in rare cases as the timestamp of a Prometheus metric should usually\n// be set by the Prometheus server during scraping. Exceptions include mirroring\n// metrics with given timestamps from other metric\n// sources.\n//\n// NewMetricWithTimestamp works best with MustNewConstMetric,\n// MustNewConstHistogram, and MustNewConstSummary, see example.\n//\n// Currently, the exposition formats used by Prometheus are limited to\n// millisecond resolution. Thus, the provided time will be rounded down to the\n// next full millisecond value.\nfunc NewMetricWithTimestamp(t time.Time, m Metric) Metric {\n\treturn timestampedMetric{Metric: m, t: t}\n}\n\ntype withExemplarsMetric struct {\n\tMetric\n\n\texemplars []*dto.Exemplar\n}\n\nfunc (m *withExemplarsMetric) Write(pb *dto.Metric) error {\n\tif err := m.Metric.Write(pb); err != nil {\n\t\treturn err\n\t}\n\n\tswitch {\n\tcase pb.Counter != nil:\n\t\tpb.Counter.Exemplar = m.exemplars[len(m.exemplars)-1]\n\tcase pb.Histogram != nil:\n\t\tfor _, e := range m.exemplars {\n\t\t\t// pb.Histogram.Bucket are sorted by UpperBound.\n\t\t\ti := sort.Search(len(pb.Histogram.Bucket), func(i int) bool {\n\t\t\t\treturn pb.Histogram.Bucket[i].GetUpperBound() >= e.GetValue()\n\t\t\t})\n\t\t\tif i < len(pb.Histogram.Bucket) {\n\t\t\t\tpb.Histogram.Bucket[i].Exemplar = e\n\t\t\t} else {\n\t\t\t\t// The +Inf bucket should be explicitly added if there is an exemplar for it, similar to non-const histogram logic in https://github.com/prometheus/client_golang/blob/main/prometheus/histogram.go#L357-L365.\n\t\t\t\tb := &dto.Bucket{\n\t\t\t\t\tCumulativeCount: proto.Uint64(pb.Histogram.GetSampleCount()),\n\t\t\t\t\tUpperBound: proto.Float64(math.Inf(1)),\n\t\t\t\t\tExemplar: e,\n\t\t\t\t}\n\t\t\t\tpb.Histogram.Bucket = append(pb.Histogram.Bucket, b)\n\t\t\t}\n\t\t}\n\tdefault:\n\t\t// TODO(bwplotka): Implement Gauge?\n\t\treturn errors.New(\"cannot inject exemplar into Gauge, Summary or Untyped\")\n\t}\n\n\treturn nil\n}\n\n// Exemplar is easier to use, user-facing representation of *dto.Exemplar.\ntype Exemplar struct {\n\tValue float64\n\tLabels Labels\n\t// Optional.\n\t// Default value (time.Time{}) indicates its empty, which should be\n\t// understood as time.Now() time at the moment of creation of metric.\n\tTimestamp time.Time\n}\n\n// NewMetricWithExemplars returns a new Metric wrapping the provided Metric with given\n// exemplars. Exemplars are validated.\n//\n// Only last applicable exemplar is injected from the list.\n// For example for Counter it means last exemplar is injected.\n// For Histogram, it means last applicable exemplar for each bucket is injected.\n//\n// NewMetricWithExemplars works best with MustNewConstMetric and\n// MustNewConstHistogram, see example.\nfunc NewMetricWithExemplars(m Metric, exemplars ...Exemplar) (Metric, error) {\n\tif len(exemplars) == 0 {\n\t\treturn nil, errors.New(\"no exemplar was passed for NewMetricWithExemplars\")\n\t}\n\n\tvar (\n\t\tnow = time.Now()\n\t\texs = make([]*dto.Exemplar, len(exemplars))\n\t\terr error\n\t)\n\tfor i, e := range exemplars {\n\t\tts := e.Timestamp\n\t\tif ts == (time.Time{}) {\n\t\t\tts = now\n\t\t}\n\t\texs[i], err = newExemplar(e.Value, ts, e.Labels)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\treturn &withExemplarsMetric{Metric: m, exemplars: exs}, nil\n}\n\n// MustNewMetricWithExemplars is a version of NewMetricWithExemplars that panics where\n// NewMetricWithExemplars would have returned an error.\nfunc MustNewMetricWithExemplars(m Metric, exemplars ...Exemplar) Metric {\n\tret, err := NewMetricWithExemplars(m, exemplars...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn ret\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/num_threads.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !js || wasm\n// +build !js wasm\n\npackage prometheus\n\nimport \"runtime\"\n\n// getRuntimeNumThreads returns the number of open OS threads.\nfunc getRuntimeNumThreads() float64 {\n\tn, _ := runtime.ThreadCreateProfile(nil)\n\treturn float64(n)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/num_threads_gopherjs.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build js && !wasm\n// +build js,!wasm\n\npackage prometheus\n\n// getRuntimeNumThreads returns the number of open OS threads.\nfunc getRuntimeNumThreads() float64 {\n\treturn 1\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/observer.go",
"content": "// Copyright 2017 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\n// Observer is the interface that wraps the Observe method, which is used by\n// Histogram and Summary to add observations.\ntype Observer interface {\n\tObserve(float64)\n}\n\n// The ObserverFunc type is an adapter to allow the use of ordinary\n// functions as Observers. If f is a function with the appropriate\n// signature, ObserverFunc(f) is an Observer that calls f.\n//\n// This adapter is usually used in connection with the Timer type, and there are\n// two general use cases:\n//\n// The most common one is to use a Gauge as the Observer for a Timer.\n// See the \"Gauge\" Timer example.\n//\n// The more advanced use case is to create a function that dynamically decides\n// which Observer to use for observing the duration. See the \"Complex\" Timer\n// example.\ntype ObserverFunc func(float64)\n\n// Observe calls f(value). It implements Observer.\nfunc (f ObserverFunc) Observe(value float64) {\n\tf(value)\n}\n\n// ObserverVec is an interface implemented by `HistogramVec` and `SummaryVec`.\ntype ObserverVec interface {\n\tGetMetricWith(Labels) (Observer, error)\n\tGetMetricWithLabelValues(lvs ...string) (Observer, error)\n\tWith(Labels) Observer\n\tWithLabelValues(...string) Observer\n\tCurryWith(Labels) (ObserverVec, error)\n\tMustCurryWith(Labels) ObserverVec\n\n\tCollector\n}\n\n// ExemplarObserver is implemented by Observers that offer the option of\n// observing a value together with an exemplar. Its ObserveWithExemplar method\n// works like the Observe method of an Observer but also replaces the currently\n// saved exemplar (if any) with a new one, created from the provided value, the\n// current time as timestamp, and the provided Labels. Empty Labels will lead to\n// a valid (label-less) exemplar. But if Labels is nil, the current exemplar is\n// left in place. ObserveWithExemplar panics if any of the provided labels are\n// invalid or if the provided labels contain more than 128 runes in total.\ntype ExemplarObserver interface {\n\tObserveWithExemplar(value float64, exemplar Labels)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/process_collector.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\ntype processCollector struct {\n\tcollectFn func(chan<- Metric)\n\tpidFn func() (int, error)\n\treportErrors bool\n\tcpuTotal *Desc\n\topenFDs, maxFDs *Desc\n\tvsize, maxVsize *Desc\n\trss *Desc\n\tstartTime *Desc\n}\n\n// ProcessCollectorOpts defines the behavior of a process metrics collector\n// created with NewProcessCollector.\ntype ProcessCollectorOpts struct {\n\t// PidFn returns the PID of the process the collector collects metrics\n\t// for. It is called upon each collection. By default, the PID of the\n\t// current process is used, as determined on construction time by\n\t// calling os.Getpid().\n\tPidFn func() (int, error)\n\t// If non-empty, each of the collected metrics is prefixed by the\n\t// provided string and an underscore (\"_\").\n\tNamespace string\n\t// If true, any error encountered during collection is reported as an\n\t// invalid metric (see NewInvalidMetric). Otherwise, errors are ignored\n\t// and the collected metrics will be incomplete. (Possibly, no metrics\n\t// will be collected at all.) While that's usually not desired, it is\n\t// appropriate for the common \"mix-in\" of process metrics, where process\n\t// metrics are nice to have, but failing to collect them should not\n\t// disrupt the collection of the remaining metrics.\n\tReportErrors bool\n}\n\n// NewProcessCollector is the obsolete version of collectors.NewProcessCollector.\n// See there for documentation.\n//\n// Deprecated: Use collectors.NewProcessCollector instead.\nfunc NewProcessCollector(opts ProcessCollectorOpts) Collector {\n\tns := \"\"\n\tif len(opts.Namespace) > 0 {\n\t\tns = opts.Namespace + \"_\"\n\t}\n\n\tc := &processCollector{\n\t\treportErrors: opts.ReportErrors,\n\t\tcpuTotal: NewDesc(\n\t\t\tns+\"process_cpu_seconds_total\",\n\t\t\t\"Total user and system CPU time spent in seconds.\",\n\t\t\tnil, nil,\n\t\t),\n\t\topenFDs: NewDesc(\n\t\t\tns+\"process_open_fds\",\n\t\t\t\"Number of open file descriptors.\",\n\t\t\tnil, nil,\n\t\t),\n\t\tmaxFDs: NewDesc(\n\t\t\tns+\"process_max_fds\",\n\t\t\t\"Maximum number of open file descriptors.\",\n\t\t\tnil, nil,\n\t\t),\n\t\tvsize: NewDesc(\n\t\t\tns+\"process_virtual_memory_bytes\",\n\t\t\t\"Virtual memory size in bytes.\",\n\t\t\tnil, nil,\n\t\t),\n\t\tmaxVsize: NewDesc(\n\t\t\tns+\"process_virtual_memory_max_bytes\",\n\t\t\t\"Maximum amount of virtual memory available in bytes.\",\n\t\t\tnil, nil,\n\t\t),\n\t\trss: NewDesc(\n\t\t\tns+\"process_resident_memory_bytes\",\n\t\t\t\"Resident memory size in bytes.\",\n\t\t\tnil, nil,\n\t\t),\n\t\tstartTime: NewDesc(\n\t\t\tns+\"process_start_time_seconds\",\n\t\t\t\"Start time of the process since unix epoch in seconds.\",\n\t\t\tnil, nil,\n\t\t),\n\t}\n\n\tif opts.PidFn == nil {\n\t\tc.pidFn = getPIDFn()\n\t} else {\n\t\tc.pidFn = opts.PidFn\n\t}\n\n\t// Set up process metric collection if supported by the runtime.\n\tif canCollectProcess() {\n\t\tc.collectFn = c.processCollect\n\t} else {\n\t\tc.collectFn = func(ch chan<- Metric) {\n\t\t\tc.reportError(ch, nil, errors.New(\"process metrics not supported on this platform\"))\n\t\t}\n\t}\n\n\treturn c\n}\n\n// Describe returns all descriptions of the collector.\nfunc (c *processCollector) Describe(ch chan<- *Desc) {\n\tch <- c.cpuTotal\n\tch <- c.openFDs\n\tch <- c.maxFDs\n\tch <- c.vsize\n\tch <- c.maxVsize\n\tch <- c.rss\n\tch <- c.startTime\n}\n\n// Collect returns the current state of all metrics of the collector.\nfunc (c *processCollector) Collect(ch chan<- Metric) {\n\tc.collectFn(ch)\n}\n\nfunc (c *processCollector) reportError(ch chan<- Metric, desc *Desc, err error) {\n\tif !c.reportErrors {\n\t\treturn\n\t}\n\tif desc == nil {\n\t\tdesc = NewInvalidDesc(err)\n\t}\n\tch <- NewInvalidMetric(desc, err)\n}\n\n// NewPidFileFn returns a function that retrieves a pid from the specified file.\n// It is meant to be used for the PidFn field in ProcessCollectorOpts.\nfunc NewPidFileFn(pidFilePath string) func() (int, error) {\n\treturn func() (int, error) {\n\t\tcontent, err := os.ReadFile(pidFilePath)\n\t\tif err != nil {\n\t\t\treturn 0, fmt.Errorf(\"can't read pid file %q: %w\", pidFilePath, err)\n\t\t}\n\t\tpid, err := strconv.Atoi(strings.TrimSpace(string(content)))\n\t\tif err != nil {\n\t\t\treturn 0, fmt.Errorf(\"can't parse pid file %q: %w\", pidFilePath, err)\n\t\t}\n\n\t\treturn pid, nil\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/process_collector_js.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build js\n// +build js\n\npackage prometheus\n\nfunc canCollectProcess() bool {\n\treturn false\n}\n\nfunc (c *processCollector) processCollect(ch chan<- Metric) {\n\t// noop on this platform\n\treturn\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows && !js\n// +build !windows,!js\n\npackage prometheus\n\nimport (\n\t\"github.com/prometheus/procfs\"\n)\n\nfunc canCollectProcess() bool {\n\t_, err := procfs.NewDefaultFS()\n\treturn err == nil\n}\n\nfunc (c *processCollector) processCollect(ch chan<- Metric) {\n\tpid, err := c.pidFn()\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\n\tp, err := procfs.NewProc(pid)\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\n\tif stat, err := p.Stat(); err == nil {\n\t\tch <- MustNewConstMetric(c.cpuTotal, CounterValue, stat.CPUTime())\n\t\tch <- MustNewConstMetric(c.vsize, GaugeValue, float64(stat.VirtualMemory()))\n\t\tch <- MustNewConstMetric(c.rss, GaugeValue, float64(stat.ResidentMemory()))\n\t\tif startTime, err := stat.StartTime(); err == nil {\n\t\t\tch <- MustNewConstMetric(c.startTime, GaugeValue, startTime)\n\t\t} else {\n\t\t\tc.reportError(ch, c.startTime, err)\n\t\t}\n\t} else {\n\t\tc.reportError(ch, nil, err)\n\t}\n\n\tif fds, err := p.FileDescriptorsLen(); err == nil {\n\t\tch <- MustNewConstMetric(c.openFDs, GaugeValue, float64(fds))\n\t} else {\n\t\tc.reportError(ch, c.openFDs, err)\n\t}\n\n\tif limits, err := p.Limits(); err == nil {\n\t\tch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(limits.OpenFiles))\n\t\tch <- MustNewConstMetric(c.maxVsize, GaugeValue, float64(limits.AddressSpace))\n\t} else {\n\t\tc.reportError(ch, nil, err)\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"syscall\"\n\t\"unsafe\"\n\n\t\"golang.org/x/sys/windows\"\n)\n\nfunc canCollectProcess() bool {\n\treturn true\n}\n\nvar (\n\tmodpsapi = syscall.NewLazyDLL(\"psapi.dll\")\n\tmodkernel32 = syscall.NewLazyDLL(\"kernel32.dll\")\n\n\tprocGetProcessMemoryInfo = modpsapi.NewProc(\"GetProcessMemoryInfo\")\n\tprocGetProcessHandleCount = modkernel32.NewProc(\"GetProcessHandleCount\")\n)\n\ntype processMemoryCounters struct {\n\t// System interface description\n\t// https://docs.microsoft.com/en-us/windows/desktop/api/psapi/ns-psapi-process_memory_counters_ex\n\n\t// Refer to the Golang internal implementation\n\t// https://golang.org/src/internal/syscall/windows/psapi_windows.go\n\t_ uint32\n\tPageFaultCount uint32\n\tPeakWorkingSetSize uintptr\n\tWorkingSetSize uintptr\n\tQuotaPeakPagedPoolUsage uintptr\n\tQuotaPagedPoolUsage uintptr\n\tQuotaPeakNonPagedPoolUsage uintptr\n\tQuotaNonPagedPoolUsage uintptr\n\tPagefileUsage uintptr\n\tPeakPagefileUsage uintptr\n\tPrivateUsage uintptr\n}\n\nfunc getProcessMemoryInfo(handle windows.Handle) (processMemoryCounters, error) {\n\tmem := processMemoryCounters{}\n\tr1, _, err := procGetProcessMemoryInfo.Call(\n\t\tuintptr(handle),\n\t\tuintptr(unsafe.Pointer(&mem)),\n\t\tuintptr(unsafe.Sizeof(mem)),\n\t)\n\tif r1 != 1 {\n\t\treturn mem, err\n\t} else {\n\t\treturn mem, nil\n\t}\n}\n\nfunc getProcessHandleCount(handle windows.Handle) (uint32, error) {\n\tvar count uint32\n\tr1, _, err := procGetProcessHandleCount.Call(\n\t\tuintptr(handle),\n\t\tuintptr(unsafe.Pointer(&count)),\n\t)\n\tif r1 != 1 {\n\t\treturn 0, err\n\t} else {\n\t\treturn count, nil\n\t}\n}\n\nfunc (c *processCollector) processCollect(ch chan<- Metric) {\n\th, err := windows.GetCurrentProcess()\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\n\tvar startTime, exitTime, kernelTime, userTime windows.Filetime\n\terr = windows.GetProcessTimes(h, &startTime, &exitTime, &kernelTime, &userTime)\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\tch <- MustNewConstMetric(c.startTime, GaugeValue, float64(startTime.Nanoseconds()/1e9))\n\tch <- MustNewConstMetric(c.cpuTotal, CounterValue, fileTimeToSeconds(kernelTime)+fileTimeToSeconds(userTime))\n\n\tmem, err := getProcessMemoryInfo(h)\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\tch <- MustNewConstMetric(c.vsize, GaugeValue, float64(mem.PrivateUsage))\n\tch <- MustNewConstMetric(c.rss, GaugeValue, float64(mem.WorkingSetSize))\n\n\thandles, err := getProcessHandleCount(h)\n\tif err != nil {\n\t\tc.reportError(ch, nil, err)\n\t\treturn\n\t}\n\tch <- MustNewConstMetric(c.openFDs, GaugeValue, float64(handles))\n\tch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(16*1024*1024)) // Windows has a hard-coded max limit, not per-process.\n}\n\nfunc fileTimeToSeconds(ft windows.Filetime) float64 {\n\treturn float64(uint64(ft.HighDateTime)<<32+uint64(ft.LowDateTime)) / 1e7\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go",
"content": "// Copyright 2017 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage promhttp\n\nimport (\n\t\"bufio\"\n\t\"io\"\n\t\"net\"\n\t\"net/http\"\n)\n\nconst (\n\tcloseNotifier = 1 << iota\n\tflusher\n\thijacker\n\treaderFrom\n\tpusher\n)\n\ntype delegator interface {\n\thttp.ResponseWriter\n\n\tStatus() int\n\tWritten() int64\n}\n\ntype responseWriterDelegator struct {\n\thttp.ResponseWriter\n\n\tstatus int\n\twritten int64\n\twroteHeader bool\n\tobserveWriteHeader func(int)\n}\n\nfunc (r *responseWriterDelegator) Status() int {\n\treturn r.status\n}\n\nfunc (r *responseWriterDelegator) Written() int64 {\n\treturn r.written\n}\n\nfunc (r *responseWriterDelegator) WriteHeader(code int) {\n\tif r.observeWriteHeader != nil && !r.wroteHeader {\n\t\t// Only call observeWriteHeader for the 1st time. It's a bug if\n\t\t// WriteHeader is called more than once, but we want to protect\n\t\t// against it here. Note that we still delegate the WriteHeader\n\t\t// to the original ResponseWriter to not mask the bug from it.\n\t\tr.observeWriteHeader(code)\n\t}\n\tr.status = code\n\tr.wroteHeader = true\n\tr.ResponseWriter.WriteHeader(code)\n}\n\nfunc (r *responseWriterDelegator) Write(b []byte) (int, error) {\n\t// If applicable, call WriteHeader here so that observeWriteHeader is\n\t// handled appropriately.\n\tif !r.wroteHeader {\n\t\tr.WriteHeader(http.StatusOK)\n\t}\n\tn, err := r.ResponseWriter.Write(b)\n\tr.written += int64(n)\n\treturn n, err\n}\n\ntype (\n\tcloseNotifierDelegator struct{ *responseWriterDelegator }\n\tflusherDelegator struct{ *responseWriterDelegator }\n\thijackerDelegator struct{ *responseWriterDelegator }\n\treaderFromDelegator struct{ *responseWriterDelegator }\n\tpusherDelegator struct{ *responseWriterDelegator }\n)\n\nfunc (d closeNotifierDelegator) CloseNotify() <-chan bool {\n\t//nolint:staticcheck // Ignore SA1019. http.CloseNotifier is deprecated but we keep it here to not break existing users.\n\treturn d.ResponseWriter.(http.CloseNotifier).CloseNotify()\n}\n\nfunc (d flusherDelegator) Flush() {\n\t// If applicable, call WriteHeader here so that observeWriteHeader is\n\t// handled appropriately.\n\tif !d.wroteHeader {\n\t\td.WriteHeader(http.StatusOK)\n\t}\n\td.ResponseWriter.(http.Flusher).Flush()\n}\n\nfunc (d hijackerDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) {\n\treturn d.ResponseWriter.(http.Hijacker).Hijack()\n}\n\nfunc (d readerFromDelegator) ReadFrom(re io.Reader) (int64, error) {\n\t// If applicable, call WriteHeader here so that observeWriteHeader is\n\t// handled appropriately.\n\tif !d.wroteHeader {\n\t\td.WriteHeader(http.StatusOK)\n\t}\n\tn, err := d.ResponseWriter.(io.ReaderFrom).ReadFrom(re)\n\td.written += n\n\treturn n, err\n}\n\nfunc (d pusherDelegator) Push(target string, opts *http.PushOptions) error {\n\treturn d.ResponseWriter.(http.Pusher).Push(target, opts)\n}\n\nvar pickDelegator = make([]func(*responseWriterDelegator) delegator, 32)\n\nfunc init() {\n\t// TODO(beorn7): Code generation would help here.\n\tpickDelegator[0] = func(d *responseWriterDelegator) delegator { // 0\n\t\treturn d\n\t}\n\tpickDelegator[closeNotifier] = func(d *responseWriterDelegator) delegator { // 1\n\t\treturn closeNotifierDelegator{d}\n\t}\n\tpickDelegator[flusher] = func(d *responseWriterDelegator) delegator { // 2\n\t\treturn flusherDelegator{d}\n\t}\n\tpickDelegator[flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 3\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[hijacker] = func(d *responseWriterDelegator) delegator { // 4\n\t\treturn hijackerDelegator{d}\n\t}\n\tpickDelegator[hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 5\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Hijacker\n\t\t\thttp.CloseNotifier\n\t\t}{d, hijackerDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 6\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t}{d, hijackerDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 7\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[readerFrom] = func(d *responseWriterDelegator) delegator { // 8\n\t\treturn readerFromDelegator{d}\n\t}\n\tpickDelegator[readerFrom+closeNotifier] = func(d *responseWriterDelegator) delegator { // 9\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.CloseNotifier\n\t\t}{d, readerFromDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 10\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Flusher\n\t\t}{d, readerFromDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 11\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 12\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t}{d, readerFromDelegator{d}, hijackerDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 13\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.CloseNotifier\n\t\t}{d, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 14\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t}{d, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 15\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher] = func(d *responseWriterDelegator) delegator { // 16\n\t\treturn pusherDelegator{d}\n\t}\n\tpickDelegator[pusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 17\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+flusher] = func(d *responseWriterDelegator) delegator { // 18\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Flusher\n\t\t}{d, pusherDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[pusher+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 19\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+hijacker] = func(d *responseWriterDelegator) delegator { // 20\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Hijacker\n\t\t}{d, pusherDelegator{d}, hijackerDelegator{d}}\n\t}\n\tpickDelegator[pusher+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 21\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Hijacker\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 22\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t}{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[pusher+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 23\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom] = func(d *responseWriterDelegator) delegator { // 24\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+closeNotifier] = func(d *responseWriterDelegator) delegator { // 25\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 26\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Flusher\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 27\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 28\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 29\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 30\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}\n\t}\n\tpickDelegator[pusher+readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 31\n\t\treturn struct {\n\t\t\t*responseWriterDelegator\n\t\t\thttp.Pusher\n\t\t\tio.ReaderFrom\n\t\t\thttp.Hijacker\n\t\t\thttp.Flusher\n\t\t\thttp.CloseNotifier\n\t\t}{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}\n\t}\n}\n\nfunc newDelegator(w http.ResponseWriter, observeWriteHeaderFunc func(int)) delegator {\n\td := &responseWriterDelegator{\n\t\tResponseWriter: w,\n\t\tobserveWriteHeader: observeWriteHeaderFunc,\n\t}\n\n\tid := 0\n\t//nolint:staticcheck // Ignore SA1019. http.CloseNotifier is deprecated but we keep it here to not break existing users.\n\tif _, ok := w.(http.CloseNotifier); ok {\n\t\tid += closeNotifier\n\t}\n\tif _, ok := w.(http.Flusher); ok {\n\t\tid += flusher\n\t}\n\tif _, ok := w.(http.Hijacker); ok {\n\t\tid += hijacker\n\t}\n\tif _, ok := w.(io.ReaderFrom); ok {\n\t\tid += readerFrom\n\t}\n\tif _, ok := w.(http.Pusher); ok {\n\t\tid += pusher\n\t}\n\n\treturn pickDelegator[id](d)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go",
"content": "// Copyright 2016 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package promhttp provides tooling around HTTP servers and clients.\n//\n// First, the package allows the creation of http.Handler instances to expose\n// Prometheus metrics via HTTP. promhttp.Handler acts on the\n// prometheus.DefaultGatherer. With HandlerFor, you can create a handler for a\n// custom registry or anything that implements the Gatherer interface. It also\n// allows the creation of handlers that act differently on errors or allow to\n// log errors.\n//\n// Second, the package provides tooling to instrument instances of http.Handler\n// via middleware. Middleware wrappers follow the naming scheme\n// InstrumentHandlerX, where X describes the intended use of the middleware.\n// See each function's doc comment for specific details.\n//\n// Finally, the package allows for an http.RoundTripper to be instrumented via\n// middleware. Middleware wrappers follow the naming scheme\n// InstrumentRoundTripperX, where X describes the intended use of the\n// middleware. See each function's doc comment for specific details.\npackage promhttp\n\nimport (\n\t\"compress/gzip\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/prometheus/common/expfmt\"\n\n\t\"github.com/prometheus/client_golang/prometheus\"\n)\n\nconst (\n\tcontentTypeHeader = \"Content-Type\"\n\tcontentEncodingHeader = \"Content-Encoding\"\n\tacceptEncodingHeader = \"Accept-Encoding\"\n)\n\nvar gzipPool = sync.Pool{\n\tNew: func() interface{} {\n\t\treturn gzip.NewWriter(nil)\n\t},\n}\n\n// Handler returns an http.Handler for the prometheus.DefaultGatherer, using\n// default HandlerOpts, i.e. it reports the first error as an HTTP error, it has\n// no error logging, and it applies compression if requested by the client.\n//\n// The returned http.Handler is already instrumented using the\n// InstrumentMetricHandler function and the prometheus.DefaultRegisterer. If you\n// create multiple http.Handlers by separate calls of the Handler function, the\n// metrics used for instrumentation will be shared between them, providing\n// global scrape counts.\n//\n// This function is meant to cover the bulk of basic use cases. If you are doing\n// anything that requires more customization (including using a non-default\n// Gatherer, different instrumentation, and non-default HandlerOpts), use the\n// HandlerFor function. See there for details.\nfunc Handler() http.Handler {\n\treturn InstrumentMetricHandler(\n\t\tprometheus.DefaultRegisterer, HandlerFor(prometheus.DefaultGatherer, HandlerOpts{}),\n\t)\n}\n\n// HandlerFor returns an uninstrumented http.Handler for the provided\n// Gatherer. The behavior of the Handler is defined by the provided\n// HandlerOpts. Thus, HandlerFor is useful to create http.Handlers for custom\n// Gatherers, with non-default HandlerOpts, and/or with custom (or no)\n// instrumentation. Use the InstrumentMetricHandler function to apply the same\n// kind of instrumentation as it is used by the Handler function.\nfunc HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {\n\treturn HandlerForTransactional(prometheus.ToTransactionalGatherer(reg), opts)\n}\n\n// HandlerForTransactional is like HandlerFor, but it uses transactional gather, which\n// can safely change in-place returned *dto.MetricFamily before call to `Gather` and after\n// call to `done` of that `Gather`.\nfunc HandlerForTransactional(reg prometheus.TransactionalGatherer, opts HandlerOpts) http.Handler {\n\tvar (\n\t\tinFlightSem chan struct{}\n\t\terrCnt = prometheus.NewCounterVec(\n\t\t\tprometheus.CounterOpts{\n\t\t\t\tName: \"promhttp_metric_handler_errors_total\",\n\t\t\t\tHelp: \"Total number of internal errors encountered by the promhttp metric handler.\",\n\t\t\t},\n\t\t\t[]string{\"cause\"},\n\t\t)\n\t)\n\n\tif opts.MaxRequestsInFlight > 0 {\n\t\tinFlightSem = make(chan struct{}, opts.MaxRequestsInFlight)\n\t}\n\tif opts.Registry != nil {\n\t\t// Initialize all possibilities that can occur below.\n\t\terrCnt.WithLabelValues(\"gathering\")\n\t\terrCnt.WithLabelValues(\"encoding\")\n\t\tif err := opts.Registry.Register(errCnt); err != nil {\n\t\t\tare := &prometheus.AlreadyRegisteredError{}\n\t\t\tif errors.As(err, are) {\n\t\t\t\terrCnt = are.ExistingCollector.(*prometheus.CounterVec)\n\t\t\t} else {\n\t\t\t\tpanic(err)\n\t\t\t}\n\t\t}\n\t}\n\n\th := http.HandlerFunc(func(rsp http.ResponseWriter, req *http.Request) {\n\t\tif inFlightSem != nil {\n\t\t\tselect {\n\t\t\tcase inFlightSem <- struct{}{}: // All good, carry on.\n\t\t\t\tdefer func() { <-inFlightSem }()\n\t\t\tdefault:\n\t\t\t\thttp.Error(rsp, fmt.Sprintf(\n\t\t\t\t\t\"Limit of concurrent requests reached (%d), try again later.\", opts.MaxRequestsInFlight,\n\t\t\t\t), http.StatusServiceUnavailable)\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t\tmfs, done, err := reg.Gather()\n\t\tdefer done()\n\t\tif err != nil {\n\t\t\tif opts.ErrorLog != nil {\n\t\t\t\topts.ErrorLog.Println(\"error gathering metrics:\", err)\n\t\t\t}\n\t\t\terrCnt.WithLabelValues(\"gathering\").Inc()\n\t\t\tswitch opts.ErrorHandling {\n\t\t\tcase PanicOnError:\n\t\t\t\tpanic(err)\n\t\t\tcase ContinueOnError:\n\t\t\t\tif len(mfs) == 0 {\n\t\t\t\t\t// Still report the error if no metrics have been gathered.\n\t\t\t\t\thttpError(rsp, err)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\tcase HTTPErrorOnError:\n\t\t\t\thttpError(rsp, err)\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\tvar contentType expfmt.Format\n\t\tif opts.EnableOpenMetrics {\n\t\t\tcontentType = expfmt.NegotiateIncludingOpenMetrics(req.Header)\n\t\t} else {\n\t\t\tcontentType = expfmt.Negotiate(req.Header)\n\t\t}\n\t\theader := rsp.Header()\n\t\theader.Set(contentTypeHeader, string(contentType))\n\n\t\tw := io.Writer(rsp)\n\t\tif !opts.DisableCompression && gzipAccepted(req.Header) {\n\t\t\theader.Set(contentEncodingHeader, \"gzip\")\n\t\t\tgz := gzipPool.Get().(*gzip.Writer)\n\t\t\tdefer gzipPool.Put(gz)\n\n\t\t\tgz.Reset(w)\n\t\t\tdefer gz.Close()\n\n\t\t\tw = gz\n\t\t}\n\n\t\tenc := expfmt.NewEncoder(w, contentType)\n\n\t\t// handleError handles the error according to opts.ErrorHandling\n\t\t// and returns true if we have to abort after the handling.\n\t\thandleError := func(err error) bool {\n\t\t\tif err == nil {\n\t\t\t\treturn false\n\t\t\t}\n\t\t\tif opts.ErrorLog != nil {\n\t\t\t\topts.ErrorLog.Println(\"error encoding and sending metric family:\", err)\n\t\t\t}\n\t\t\terrCnt.WithLabelValues(\"encoding\").Inc()\n\t\t\tswitch opts.ErrorHandling {\n\t\t\tcase PanicOnError:\n\t\t\t\tpanic(err)\n\t\t\tcase HTTPErrorOnError:\n\t\t\t\t// We cannot really send an HTTP error at this\n\t\t\t\t// point because we most likely have written\n\t\t\t\t// something to rsp already. But at least we can\n\t\t\t\t// stop sending.\n\t\t\t\treturn true\n\t\t\t}\n\t\t\t// Do nothing in all other cases, including ContinueOnError.\n\t\t\treturn false\n\t\t}\n\n\t\tfor _, mf := range mfs {\n\t\t\tif handleError(enc.Encode(mf)) {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t\tif closer, ok := enc.(expfmt.Closer); ok {\n\t\t\t// This in particular takes care of the final \"# EOF\\n\" line for OpenMetrics.\n\t\t\tif handleError(closer.Close()) {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t})\n\n\tif opts.Timeout <= 0 {\n\t\treturn h\n\t}\n\treturn http.TimeoutHandler(h, opts.Timeout, fmt.Sprintf(\n\t\t\"Exceeded configured timeout of %v.\\n\",\n\t\topts.Timeout,\n\t))\n}\n\n// InstrumentMetricHandler is usually used with an http.Handler returned by the\n// HandlerFor function. It instruments the provided http.Handler with two\n// metrics: A counter vector \"promhttp_metric_handler_requests_total\" to count\n// scrapes partitioned by HTTP status code, and a gauge\n// \"promhttp_metric_handler_requests_in_flight\" to track the number of\n// simultaneous scrapes. This function idempotently registers collectors for\n// both metrics with the provided Registerer. It panics if the registration\n// fails. The provided metrics are useful to see how many scrapes hit the\n// monitored target (which could be from different Prometheus servers or other\n// scrapers), and how often they overlap (which would result in more than one\n// scrape in flight at the same time). Note that the scrapes-in-flight gauge\n// will contain the scrape by which it is exposed, while the scrape counter will\n// only get incremented after the scrape is complete (as only then the status\n// code is known). For tracking scrape durations, use the\n// \"scrape_duration_seconds\" gauge created by the Prometheus server upon each\n// scrape.\nfunc InstrumentMetricHandler(reg prometheus.Registerer, handler http.Handler) http.Handler {\n\tcnt := prometheus.NewCounterVec(\n\t\tprometheus.CounterOpts{\n\t\t\tName: \"promhttp_metric_handler_requests_total\",\n\t\t\tHelp: \"Total number of scrapes by HTTP status code.\",\n\t\t},\n\t\t[]string{\"code\"},\n\t)\n\t// Initialize the most likely HTTP status codes.\n\tcnt.WithLabelValues(\"200\")\n\tcnt.WithLabelValues(\"500\")\n\tcnt.WithLabelValues(\"503\")\n\tif err := reg.Register(cnt); err != nil {\n\t\tare := &prometheus.AlreadyRegisteredError{}\n\t\tif errors.As(err, are) {\n\t\t\tcnt = are.ExistingCollector.(*prometheus.CounterVec)\n\t\t} else {\n\t\t\tpanic(err)\n\t\t}\n\t}\n\n\tgge := prometheus.NewGauge(prometheus.GaugeOpts{\n\t\tName: \"promhttp_metric_handler_requests_in_flight\",\n\t\tHelp: \"Current number of scrapes being served.\",\n\t})\n\tif err := reg.Register(gge); err != nil {\n\t\tare := &prometheus.AlreadyRegisteredError{}\n\t\tif errors.As(err, are) {\n\t\t\tgge = are.ExistingCollector.(prometheus.Gauge)\n\t\t} else {\n\t\t\tpanic(err)\n\t\t}\n\t}\n\n\treturn InstrumentHandlerCounter(cnt, InstrumentHandlerInFlight(gge, handler))\n}\n\n// HandlerErrorHandling defines how a Handler serving metrics will handle\n// errors.\ntype HandlerErrorHandling int\n\n// These constants cause handlers serving metrics to behave as described if\n// errors are encountered.\nconst (\n\t// Serve an HTTP status code 500 upon the first error\n\t// encountered. Report the error message in the body. Note that HTTP\n\t// errors cannot be served anymore once the beginning of a regular\n\t// payload has been sent. Thus, in the (unlikely) case that encoding the\n\t// payload into the negotiated wire format fails, serving the response\n\t// will simply be aborted. Set an ErrorLog in HandlerOpts to detect\n\t// those errors.\n\tHTTPErrorOnError HandlerErrorHandling = iota\n\t// Ignore errors and try to serve as many metrics as possible. However,\n\t// if no metrics can be served, serve an HTTP status code 500 and the\n\t// last error message in the body. Only use this in deliberate \"best\n\t// effort\" metrics collection scenarios. In this case, it is highly\n\t// recommended to provide other means of detecting errors: By setting an\n\t// ErrorLog in HandlerOpts, the errors are logged. By providing a\n\t// Registry in HandlerOpts, the exposed metrics include an error counter\n\t// \"promhttp_metric_handler_errors_total\", which can be used for\n\t// alerts.\n\tContinueOnError\n\t// Panic upon the first error encountered (useful for \"crash only\" apps).\n\tPanicOnError\n)\n\n// Logger is the minimal interface HandlerOpts needs for logging. Note that\n// log.Logger from the standard library implements this interface, and it is\n// easy to implement by custom loggers, if they don't do so already anyway.\ntype Logger interface {\n\tPrintln(v ...interface{})\n}\n\n// HandlerOpts specifies options how to serve metrics via an http.Handler. The\n// zero value of HandlerOpts is a reasonable default.\ntype HandlerOpts struct {\n\t// ErrorLog specifies an optional Logger for errors collecting and\n\t// serving metrics. If nil, errors are not logged at all. Note that the\n\t// type of a reported error is often prometheus.MultiError, which\n\t// formats into a multi-line error string. If you want to avoid the\n\t// latter, create a Logger implementation that detects a\n\t// prometheus.MultiError and formats the contained errors into one line.\n\tErrorLog Logger\n\t// ErrorHandling defines how errors are handled. Note that errors are\n\t// logged regardless of the configured ErrorHandling provided ErrorLog\n\t// is not nil.\n\tErrorHandling HandlerErrorHandling\n\t// If Registry is not nil, it is used to register a metric\n\t// \"promhttp_metric_handler_errors_total\", partitioned by \"cause\". A\n\t// failed registration causes a panic. Note that this error counter is\n\t// different from the instrumentation you get from the various\n\t// InstrumentHandler... helpers. It counts errors that don't necessarily\n\t// result in a non-2xx HTTP status code. There are two typical cases:\n\t// (1) Encoding errors that only happen after streaming of the HTTP body\n\t// has already started (and the status code 200 has been sent). This\n\t// should only happen with custom collectors. (2) Collection errors with\n\t// no effect on the HTTP status code because ErrorHandling is set to\n\t// ContinueOnError.\n\tRegistry prometheus.Registerer\n\t// If DisableCompression is true, the handler will never compress the\n\t// response, even if requested by the client.\n\tDisableCompression bool\n\t// The number of concurrent HTTP requests is limited to\n\t// MaxRequestsInFlight. Additional requests are responded to with 503\n\t// Service Unavailable and a suitable message in the body. If\n\t// MaxRequestsInFlight is 0 or negative, no limit is applied.\n\tMaxRequestsInFlight int\n\t// If handling a request takes longer than Timeout, it is responded to\n\t// with 503 ServiceUnavailable and a suitable Message. No timeout is\n\t// applied if Timeout is 0 or negative. Note that with the current\n\t// implementation, reaching the timeout simply ends the HTTP requests as\n\t// described above (and even that only if sending of the body hasn't\n\t// started yet), while the bulk work of gathering all the metrics keeps\n\t// running in the background (with the eventual result to be thrown\n\t// away). Until the implementation is improved, it is recommended to\n\t// implement a separate timeout in potentially slow Collectors.\n\tTimeout time.Duration\n\t// If true, the experimental OpenMetrics encoding is added to the\n\t// possible options during content negotiation. Note that Prometheus\n\t// 2.5.0+ will negotiate OpenMetrics as first priority. OpenMetrics is\n\t// the only way to transmit exemplars. However, the move to OpenMetrics\n\t// is not completely transparent. Most notably, the values of \"quantile\"\n\t// labels of Summaries and \"le\" labels of Histograms are formatted with\n\t// a trailing \".0\" if they would otherwise look like integer numbers\n\t// (which changes the identity of the resulting series on the Prometheus\n\t// server).\n\tEnableOpenMetrics bool\n}\n\n// gzipAccepted returns whether the client will accept gzip-encoded content.\nfunc gzipAccepted(header http.Header) bool {\n\ta := header.Get(acceptEncodingHeader)\n\tparts := strings.Split(a, \",\")\n\tfor _, part := range parts {\n\t\tpart = strings.TrimSpace(part)\n\t\tif part == \"gzip\" || strings.HasPrefix(part, \"gzip;\") {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// httpError removes any content-encoding header and then calls http.Error with\n// the provided error and http.StatusInternalServerError. Error contents is\n// supposed to be uncompressed plain text. Same as with a plain http.Error, this\n// must not be called if the header or any payload has already been sent.\nfunc httpError(rsp http.ResponseWriter, err error) {\n\trsp.Header().Del(contentEncodingHeader)\n\thttp.Error(\n\t\trsp,\n\t\t\"An error has occurred while serving metrics:\\n\\n\"+err.Error(),\n\t\thttp.StatusInternalServerError,\n\t)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go",
"content": "// Copyright 2017 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage promhttp\n\nimport (\n\t\"crypto/tls\"\n\t\"net/http\"\n\t\"net/http/httptrace\"\n\t\"time\"\n\n\t\"github.com/prometheus/client_golang/prometheus\"\n)\n\n// The RoundTripperFunc type is an adapter to allow the use of ordinary\n// functions as RoundTrippers. If f is a function with the appropriate\n// signature, RountTripperFunc(f) is a RoundTripper that calls f.\ntype RoundTripperFunc func(req *http.Request) (*http.Response, error)\n\n// RoundTrip implements the RoundTripper interface.\nfunc (rt RoundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) {\n\treturn rt(r)\n}\n\n// InstrumentRoundTripperInFlight is a middleware that wraps the provided\n// http.RoundTripper. It sets the provided prometheus.Gauge to the number of\n// requests currently handled by the wrapped http.RoundTripper.\n//\n// See the example for ExampleInstrumentRoundTripperDuration for example usage.\nfunc InstrumentRoundTripperInFlight(gauge prometheus.Gauge, next http.RoundTripper) RoundTripperFunc {\n\treturn func(r *http.Request) (*http.Response, error) {\n\t\tgauge.Inc()\n\t\tdefer gauge.Dec()\n\t\treturn next.RoundTrip(r)\n\t}\n}\n\n// InstrumentRoundTripperCounter is a middleware that wraps the provided\n// http.RoundTripper to observe the request result with the provided CounterVec.\n// The CounterVec must have zero, one, or two non-const non-curried labels. For\n// those, the only allowed label names are \"code\" and \"method\". The function\n// panics otherwise. For the \"method\" label a predefined default label value set\n// is used to filter given values. Values besides predefined values will count\n// as `unknown` method.`WithExtraMethods` can be used to add more\n// methods to the set. Partitioning of the CounterVec happens by HTTP status code\n// and/or HTTP method if the respective instance label names are present in the\n// CounterVec. For unpartitioned counting, use a CounterVec with zero labels.\n//\n// If the wrapped RoundTripper panics or returns a non-nil error, the Counter\n// is not incremented.\n//\n// Use with WithExemplarFromContext to instrument the exemplars on the counter of requests.\n//\n// See the example for ExampleInstrumentRoundTripperDuration for example usage.\nfunc InstrumentRoundTripperCounter(counter *prometheus.CounterVec, next http.RoundTripper, opts ...Option) RoundTripperFunc {\n\trtOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(rtOpts)\n\t}\n\n\tcode, method := checkLabels(counter)\n\n\treturn func(r *http.Request) (*http.Response, error) {\n\t\tresp, err := next.RoundTrip(r)\n\t\tif err == nil {\n\t\t\taddWithExemplar(\n\t\t\t\tcounter.With(labels(code, method, r.Method, resp.StatusCode, rtOpts.extraMethods...)),\n\t\t\t\t1,\n\t\t\t\trtOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t}\n\t\treturn resp, err\n\t}\n}\n\n// InstrumentRoundTripperDuration is a middleware that wraps the provided\n// http.RoundTripper to observe the request duration with the provided\n// ObserverVec. The ObserverVec must have zero, one, or two non-const\n// non-curried labels. For those, the only allowed label names are \"code\" and\n// \"method\". The function panics otherwise. For the \"method\" label a predefined\n// default label value set is used to filter given values. Values besides\n// predefined values will count as `unknown` method. `WithExtraMethods`\n// can be used to add more methods to the set. The Observe method of the Observer\n// in the ObserverVec is called with the request duration in\n// seconds. Partitioning happens by HTTP status code and/or HTTP method if the\n// respective instance label names are present in the ObserverVec. For\n// unpartitioned observations, use an ObserverVec with zero labels. Note that\n// partitioning of Histograms is expensive and should be used judiciously.\n//\n// If the wrapped RoundTripper panics or returns a non-nil error, no values are\n// reported.\n//\n// Use with WithExemplarFromContext to instrument the exemplars on the duration histograms.\n//\n// Note that this method is only guaranteed to never observe negative durations\n// if used with Go1.9+.\nfunc InstrumentRoundTripperDuration(obs prometheus.ObserverVec, next http.RoundTripper, opts ...Option) RoundTripperFunc {\n\trtOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(rtOpts)\n\t}\n\n\tcode, method := checkLabels(obs)\n\n\treturn func(r *http.Request) (*http.Response, error) {\n\t\tstart := time.Now()\n\t\tresp, err := next.RoundTrip(r)\n\t\tif err == nil {\n\t\t\tobserveWithExemplar(\n\t\t\t\tobs.With(labels(code, method, r.Method, resp.StatusCode, rtOpts.extraMethods...)),\n\t\t\t\ttime.Since(start).Seconds(),\n\t\t\t\trtOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t}\n\t\treturn resp, err\n\t}\n}\n\n// InstrumentTrace is used to offer flexibility in instrumenting the available\n// httptrace.ClientTrace hook functions. Each function is passed a float64\n// representing the time in seconds since the start of the http request. A user\n// may choose to use separately buckets Histograms, or implement custom\n// instance labels on a per function basis.\ntype InstrumentTrace struct {\n\tGotConn func(float64)\n\tPutIdleConn func(float64)\n\tGotFirstResponseByte func(float64)\n\tGot100Continue func(float64)\n\tDNSStart func(float64)\n\tDNSDone func(float64)\n\tConnectStart func(float64)\n\tConnectDone func(float64)\n\tTLSHandshakeStart func(float64)\n\tTLSHandshakeDone func(float64)\n\tWroteHeaders func(float64)\n\tWait100Continue func(float64)\n\tWroteRequest func(float64)\n}\n\n// InstrumentRoundTripperTrace is a middleware that wraps the provided\n// RoundTripper and reports times to hook functions provided in the\n// InstrumentTrace struct. Hook functions that are not present in the provided\n// InstrumentTrace struct are ignored. Times reported to the hook functions are\n// time since the start of the request. Only with Go1.9+, those times are\n// guaranteed to never be negative. (Earlier Go versions are not using a\n// monotonic clock.) Note that partitioning of Histograms is expensive and\n// should be used judiciously.\n//\n// For hook functions that receive an error as an argument, no observations are\n// made in the event of a non-nil error value.\n//\n// See the example for ExampleInstrumentRoundTripperDuration for example usage.\nfunc InstrumentRoundTripperTrace(it *InstrumentTrace, next http.RoundTripper) RoundTripperFunc {\n\treturn func(r *http.Request) (*http.Response, error) {\n\t\tstart := time.Now()\n\n\t\ttrace := &httptrace.ClientTrace{\n\t\t\tGotConn: func(_ httptrace.GotConnInfo) {\n\t\t\t\tif it.GotConn != nil {\n\t\t\t\t\tit.GotConn(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tPutIdleConn: func(err error) {\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif it.PutIdleConn != nil {\n\t\t\t\t\tit.PutIdleConn(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tDNSStart: func(_ httptrace.DNSStartInfo) {\n\t\t\t\tif it.DNSStart != nil {\n\t\t\t\t\tit.DNSStart(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tDNSDone: func(_ httptrace.DNSDoneInfo) {\n\t\t\t\tif it.DNSDone != nil {\n\t\t\t\t\tit.DNSDone(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tConnectStart: func(_, _ string) {\n\t\t\t\tif it.ConnectStart != nil {\n\t\t\t\t\tit.ConnectStart(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tConnectDone: func(_, _ string, err error) {\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif it.ConnectDone != nil {\n\t\t\t\t\tit.ConnectDone(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tGotFirstResponseByte: func() {\n\t\t\t\tif it.GotFirstResponseByte != nil {\n\t\t\t\t\tit.GotFirstResponseByte(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tGot100Continue: func() {\n\t\t\t\tif it.Got100Continue != nil {\n\t\t\t\t\tit.Got100Continue(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tTLSHandshakeStart: func() {\n\t\t\t\tif it.TLSHandshakeStart != nil {\n\t\t\t\t\tit.TLSHandshakeStart(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tTLSHandshakeDone: func(_ tls.ConnectionState, err error) {\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif it.TLSHandshakeDone != nil {\n\t\t\t\t\tit.TLSHandshakeDone(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tWroteHeaders: func() {\n\t\t\t\tif it.WroteHeaders != nil {\n\t\t\t\t\tit.WroteHeaders(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tWait100Continue: func() {\n\t\t\t\tif it.Wait100Continue != nil {\n\t\t\t\t\tit.Wait100Continue(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t\tWroteRequest: func(_ httptrace.WroteRequestInfo) {\n\t\t\t\tif it.WroteRequest != nil {\n\t\t\t\t\tit.WroteRequest(time.Since(start).Seconds())\n\t\t\t\t}\n\t\t\t},\n\t\t}\n\t\tr = r.WithContext(httptrace.WithClientTrace(r.Context(), trace))\n\n\t\treturn next.RoundTrip(r)\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go",
"content": "// Copyright 2017 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage promhttp\n\nimport (\n\t\"errors\"\n\t\"net/http\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/prometheus/client_golang/prometheus\"\n)\n\n// magicString is used for the hacky label test in checkLabels. Remove once fixed.\nconst magicString = \"zZgWfBxLqvG8kc8IMv3POi2Bb0tZI3vAnBx+gBaFi9FyPzB/CzKUer1yufDa\"\n\n// observeWithExemplar is a wrapper for [prometheus.ExemplarAdder.ExemplarObserver],\n// which falls back to [prometheus.Observer.Observe] if no labels are provided.\nfunc observeWithExemplar(obs prometheus.Observer, val float64, labels map[string]string) {\n\tif labels == nil {\n\t\tobs.Observe(val)\n\t\treturn\n\t}\n\tobs.(prometheus.ExemplarObserver).ObserveWithExemplar(val, labels)\n}\n\n// addWithExemplar is a wrapper for [prometheus.ExemplarAdder.AddWithExemplar],\n// which falls back to [prometheus.Counter.Add] if no labels are provided.\nfunc addWithExemplar(obs prometheus.Counter, val float64, labels map[string]string) {\n\tif labels == nil {\n\t\tobs.Add(val)\n\t\treturn\n\t}\n\tobs.(prometheus.ExemplarAdder).AddWithExemplar(val, labels)\n}\n\n// InstrumentHandlerInFlight is a middleware that wraps the provided\n// http.Handler. It sets the provided prometheus.Gauge to the number of\n// requests currently handled by the wrapped http.Handler.\n//\n// See the example for InstrumentHandlerDuration for example usage.\nfunc InstrumentHandlerInFlight(g prometheus.Gauge, next http.Handler) http.Handler {\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tg.Inc()\n\t\tdefer g.Dec()\n\t\tnext.ServeHTTP(w, r)\n\t})\n}\n\n// InstrumentHandlerDuration is a middleware that wraps the provided\n// http.Handler to observe the request duration with the provided ObserverVec.\n// The ObserverVec must have valid metric and label names and must have zero,\n// one, or two non-const non-curried labels. For those, the only allowed label\n// names are \"code\" and \"method\". The function panics otherwise. For the \"method\"\n// label a predefined default label value set is used to filter given values.\n// Values besides predefined values will count as `unknown` method.\n// `WithExtraMethods` can be used to add more methods to the set. The Observe\n// method of the Observer in the ObserverVec is called with the request duration\n// in seconds. Partitioning happens by HTTP status code and/or HTTP method if\n// the respective instance label names are present in the ObserverVec. For\n// unpartitioned observations, use an ObserverVec with zero labels. Note that\n// partitioning of Histograms is expensive and should be used judiciously.\n//\n// If the wrapped Handler does not set a status code, a status code of 200 is assumed.\n//\n// If the wrapped Handler panics, no values are reported.\n//\n// Note that this method is only guaranteed to never observe negative durations\n// if used with Go1.9+.\nfunc InstrumentHandlerDuration(obs prometheus.ObserverVec, next http.Handler, opts ...Option) http.HandlerFunc {\n\thOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(hOpts)\n\t}\n\n\tcode, method := checkLabels(obs)\n\n\tif code {\n\t\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\t\tnow := time.Now()\n\t\t\td := newDelegator(w, nil)\n\t\t\tnext.ServeHTTP(d, r)\n\n\t\t\tobserveWithExemplar(\n\t\t\t\tobs.With(labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)),\n\t\t\t\ttime.Since(now).Seconds(),\n\t\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t}\n\t}\n\n\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\tnow := time.Now()\n\t\tnext.ServeHTTP(w, r)\n\n\t\tobserveWithExemplar(\n\t\t\tobs.With(labels(code, method, r.Method, 0, hOpts.extraMethods...)),\n\t\t\ttime.Since(now).Seconds(),\n\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t)\n\t}\n}\n\n// InstrumentHandlerCounter is a middleware that wraps the provided http.Handler\n// to observe the request result with the provided CounterVec. The CounterVec\n// must have valid metric and label names and must have zero, one, or two\n// non-const non-curried labels. For those, the only allowed label names are\n// \"code\" and \"method\". The function panics otherwise. For the \"method\"\n// label a predefined default label value set is used to filter given values.\n// Values besides predefined values will count as `unknown` method.\n// `WithExtraMethods` can be used to add more methods to the set. Partitioning of the\n// CounterVec happens by HTTP status code and/or HTTP method if the respective\n// instance label names are present in the CounterVec. For unpartitioned\n// counting, use a CounterVec with zero labels.\n//\n// If the wrapped Handler does not set a status code, a status code of 200 is assumed.\n//\n// If the wrapped Handler panics, the Counter is not incremented.\n//\n// See the example for InstrumentHandlerDuration for example usage.\nfunc InstrumentHandlerCounter(counter *prometheus.CounterVec, next http.Handler, opts ...Option) http.HandlerFunc {\n\thOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(hOpts)\n\t}\n\n\tcode, method := checkLabels(counter)\n\n\tif code {\n\t\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\t\td := newDelegator(w, nil)\n\t\t\tnext.ServeHTTP(d, r)\n\n\t\t\taddWithExemplar(\n\t\t\t\tcounter.With(labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)),\n\t\t\t\t1,\n\t\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t}\n\t}\n\n\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\tnext.ServeHTTP(w, r)\n\t\taddWithExemplar(\n\t\t\tcounter.With(labels(code, method, r.Method, 0, hOpts.extraMethods...)),\n\t\t\t1,\n\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t)\n\t}\n}\n\n// InstrumentHandlerTimeToWriteHeader is a middleware that wraps the provided\n// http.Handler to observe with the provided ObserverVec the request duration\n// until the response headers are written. The ObserverVec must have valid\n// metric and label names and must have zero, one, or two non-const non-curried\n// labels. For those, the only allowed label names are \"code\" and \"method\". The\n// function panics otherwise. For the \"method\" label a predefined default label\n// value set is used to filter given values. Values besides predefined values\n// will count as `unknown` method.`WithExtraMethods` can be used to add more\n// methods to the set. The Observe method of the Observer in the\n// ObserverVec is called with the request duration in seconds. Partitioning\n// happens by HTTP status code and/or HTTP method if the respective instance\n// label names are present in the ObserverVec. For unpartitioned observations,\n// use an ObserverVec with zero labels. Note that partitioning of Histograms is\n// expensive and should be used judiciously.\n//\n// If the wrapped Handler panics before calling WriteHeader, no value is\n// reported.\n//\n// Note that this method is only guaranteed to never observe negative durations\n// if used with Go1.9+.\n//\n// See the example for InstrumentHandlerDuration for example usage.\nfunc InstrumentHandlerTimeToWriteHeader(obs prometheus.ObserverVec, next http.Handler, opts ...Option) http.HandlerFunc {\n\thOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(hOpts)\n\t}\n\n\tcode, method := checkLabels(obs)\n\n\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\tnow := time.Now()\n\t\td := newDelegator(w, func(status int) {\n\t\t\tobserveWithExemplar(\n\t\t\t\tobs.With(labels(code, method, r.Method, status, hOpts.extraMethods...)),\n\t\t\t\ttime.Since(now).Seconds(),\n\t\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t})\n\t\tnext.ServeHTTP(d, r)\n\t}\n}\n\n// InstrumentHandlerRequestSize is a middleware that wraps the provided\n// http.Handler to observe the request size with the provided ObserverVec. The\n// ObserverVec must have valid metric and label names and must have zero, one,\n// or two non-const non-curried labels. For those, the only allowed label names\n// are \"code\" and \"method\". The function panics otherwise. For the \"method\"\n// label a predefined default label value set is used to filter given values.\n// Values besides predefined values will count as `unknown` method.\n// `WithExtraMethods` can be used to add more methods to the set. The Observe\n// method of the Observer in the ObserverVec is called with the request size in\n// bytes. Partitioning happens by HTTP status code and/or HTTP method if the\n// respective instance label names are present in the ObserverVec. For\n// unpartitioned observations, use an ObserverVec with zero labels. Note that\n// partitioning of Histograms is expensive and should be used judiciously.\n//\n// If the wrapped Handler does not set a status code, a status code of 200 is assumed.\n//\n// If the wrapped Handler panics, no values are reported.\n//\n// See the example for InstrumentHandlerDuration for example usage.\nfunc InstrumentHandlerRequestSize(obs prometheus.ObserverVec, next http.Handler, opts ...Option) http.HandlerFunc {\n\thOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(hOpts)\n\t}\n\n\tcode, method := checkLabels(obs)\n\tif code {\n\t\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\t\td := newDelegator(w, nil)\n\t\t\tnext.ServeHTTP(d, r)\n\t\t\tsize := computeApproximateRequestSize(r)\n\t\t\tobserveWithExemplar(\n\t\t\t\tobs.With(labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)),\n\t\t\t\tfloat64(size),\n\t\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t\t)\n\t\t}\n\t}\n\n\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\tnext.ServeHTTP(w, r)\n\t\tsize := computeApproximateRequestSize(r)\n\t\tobserveWithExemplar(\n\t\t\tobs.With(labels(code, method, r.Method, 0, hOpts.extraMethods...)),\n\t\t\tfloat64(size),\n\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t)\n\t}\n}\n\n// InstrumentHandlerResponseSize is a middleware that wraps the provided\n// http.Handler to observe the response size with the provided ObserverVec. The\n// ObserverVec must have valid metric and label names and must have zero, one,\n// or two non-const non-curried labels. For those, the only allowed label names\n// are \"code\" and \"method\". The function panics otherwise. For the \"method\"\n// label a predefined default label value set is used to filter given values.\n// Values besides predefined values will count as `unknown` method.\n// `WithExtraMethods` can be used to add more methods to the set. The Observe\n// method of the Observer in the ObserverVec is called with the response size in\n// bytes. Partitioning happens by HTTP status code and/or HTTP method if the\n// respective instance label names are present in the ObserverVec. For\n// unpartitioned observations, use an ObserverVec with zero labels. Note that\n// partitioning of Histograms is expensive and should be used judiciously.\n//\n// If the wrapped Handler does not set a status code, a status code of 200 is assumed.\n//\n// If the wrapped Handler panics, no values are reported.\n//\n// See the example for InstrumentHandlerDuration for example usage.\nfunc InstrumentHandlerResponseSize(obs prometheus.ObserverVec, next http.Handler, opts ...Option) http.Handler {\n\thOpts := defaultOptions()\n\tfor _, o := range opts {\n\t\to.apply(hOpts)\n\t}\n\n\tcode, method := checkLabels(obs)\n\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\td := newDelegator(w, nil)\n\t\tnext.ServeHTTP(d, r)\n\t\tobserveWithExemplar(\n\t\t\tobs.With(labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)),\n\t\t\tfloat64(d.Written()),\n\t\t\thOpts.getExemplarFn(r.Context()),\n\t\t)\n\t})\n}\n\n// checkLabels returns whether the provided Collector has a non-const,\n// non-curried label named \"code\" and/or \"method\". It panics if the provided\n// Collector does not have a Desc or has more than one Desc or its Desc is\n// invalid. It also panics if the Collector has any non-const, non-curried\n// labels that are not named \"code\" or \"method\".\nfunc checkLabels(c prometheus.Collector) (code, method bool) {\n\t// TODO(beorn7): Remove this hacky way to check for instance labels\n\t// once Descriptors can have their dimensionality queried.\n\tvar (\n\t\tdesc *prometheus.Desc\n\t\tm prometheus.Metric\n\t\tpm dto.Metric\n\t\tlvs []string\n\t)\n\n\t// Get the Desc from the Collector.\n\tdescc := make(chan *prometheus.Desc, 1)\n\tc.Describe(descc)\n\n\tselect {\n\tcase desc = <-descc:\n\tdefault:\n\t\tpanic(\"no description provided by collector\")\n\t}\n\tselect {\n\tcase <-descc:\n\t\tpanic(\"more than one description provided by collector\")\n\tdefault:\n\t}\n\n\tclose(descc)\n\n\t// Make sure the Collector has a valid Desc by registering it with a\n\t// temporary registry.\n\tprometheus.NewRegistry().MustRegister(c)\n\n\t// Create a ConstMetric with the Desc. Since we don't know how many\n\t// variable labels there are, try for as long as it needs.\n\tfor err := errors.New(\"dummy\"); err != nil; lvs = append(lvs, magicString) {\n\t\tm, err = prometheus.NewConstMetric(desc, prometheus.UntypedValue, 0, lvs...)\n\t}\n\n\t// Write out the metric into a proto message and look at the labels.\n\t// If the value is not the magicString, it is a constLabel, which doesn't interest us.\n\t// If the label is curried, it doesn't interest us.\n\t// In all other cases, only \"code\" or \"method\" is allowed.\n\tif err := m.Write(&pm); err != nil {\n\t\tpanic(\"error checking metric for labels\")\n\t}\n\tfor _, label := range pm.Label {\n\t\tname, value := label.GetName(), label.GetValue()\n\t\tif value != magicString || isLabelCurried(c, name) {\n\t\t\tcontinue\n\t\t}\n\t\tswitch name {\n\t\tcase \"code\":\n\t\t\tcode = true\n\t\tcase \"method\":\n\t\t\tmethod = true\n\t\tdefault:\n\t\t\tpanic(\"metric partitioned with non-supported labels\")\n\t\t}\n\t}\n\treturn\n}\n\nfunc isLabelCurried(c prometheus.Collector, label string) bool {\n\t// This is even hackier than the label test above.\n\t// We essentially try to curry again and see if it works.\n\t// But for that, we need to type-convert to the two\n\t// types we use here, ObserverVec or *CounterVec.\n\tswitch v := c.(type) {\n\tcase *prometheus.CounterVec:\n\t\tif _, err := v.CurryWith(prometheus.Labels{label: \"dummy\"}); err == nil {\n\t\t\treturn false\n\t\t}\n\tcase prometheus.ObserverVec:\n\t\tif _, err := v.CurryWith(prometheus.Labels{label: \"dummy\"}); err == nil {\n\t\t\treturn false\n\t\t}\n\tdefault:\n\t\tpanic(\"unsupported metric vec type\")\n\t}\n\treturn true\n}\n\n// emptyLabels is a one-time allocation for non-partitioned metrics to avoid\n// unnecessary allocations on each request.\nvar emptyLabels = prometheus.Labels{}\n\nfunc labels(code, method bool, reqMethod string, status int, extraMethods ...string) prometheus.Labels {\n\tif !(code || method) {\n\t\treturn emptyLabels\n\t}\n\tlabels := prometheus.Labels{}\n\n\tif code {\n\t\tlabels[\"code\"] = sanitizeCode(status)\n\t}\n\tif method {\n\t\tlabels[\"method\"] = sanitizeMethod(reqMethod, extraMethods...)\n\t}\n\n\treturn labels\n}\n\nfunc computeApproximateRequestSize(r *http.Request) int {\n\ts := 0\n\tif r.URL != nil {\n\t\ts += len(r.URL.String())\n\t}\n\n\ts += len(r.Method)\n\ts += len(r.Proto)\n\tfor name, values := range r.Header {\n\t\ts += len(name)\n\t\tfor _, value := range values {\n\t\t\ts += len(value)\n\t\t}\n\t}\n\ts += len(r.Host)\n\n\t// N.B. r.Form and r.MultipartForm are assumed to be included in r.URL.\n\n\tif r.ContentLength != -1 {\n\t\ts += int(r.ContentLength)\n\t}\n\treturn s\n}\n\n// If the wrapped http.Handler has a known method, it will be sanitized and returned.\n// Otherwise, \"unknown\" will be returned. The known method list can be extended\n// as needed by using extraMethods parameter.\nfunc sanitizeMethod(m string, extraMethods ...string) string {\n\t// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods for\n\t// the methods chosen as default.\n\tswitch m {\n\tcase \"GET\", \"get\":\n\t\treturn \"get\"\n\tcase \"PUT\", \"put\":\n\t\treturn \"put\"\n\tcase \"HEAD\", \"head\":\n\t\treturn \"head\"\n\tcase \"POST\", \"post\":\n\t\treturn \"post\"\n\tcase \"DELETE\", \"delete\":\n\t\treturn \"delete\"\n\tcase \"CONNECT\", \"connect\":\n\t\treturn \"connect\"\n\tcase \"OPTIONS\", \"options\":\n\t\treturn \"options\"\n\tcase \"NOTIFY\", \"notify\":\n\t\treturn \"notify\"\n\tcase \"TRACE\", \"trace\":\n\t\treturn \"trace\"\n\tcase \"PATCH\", \"patch\":\n\t\treturn \"patch\"\n\tdefault:\n\t\tfor _, method := range extraMethods {\n\t\t\tif strings.EqualFold(m, method) {\n\t\t\t\treturn strings.ToLower(m)\n\t\t\t}\n\t\t}\n\t\treturn \"unknown\"\n\t}\n}\n\n// If the wrapped http.Handler has not set a status code, i.e. the value is\n// currently 0, sanitizeCode will return 200, for consistency with behavior in\n// the stdlib.\nfunc sanitizeCode(s int) string {\n\t// See for accepted codes https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml\n\tswitch s {\n\tcase 100:\n\t\treturn \"100\"\n\tcase 101:\n\t\treturn \"101\"\n\n\tcase 200, 0:\n\t\treturn \"200\"\n\tcase 201:\n\t\treturn \"201\"\n\tcase 202:\n\t\treturn \"202\"\n\tcase 203:\n\t\treturn \"203\"\n\tcase 204:\n\t\treturn \"204\"\n\tcase 205:\n\t\treturn \"205\"\n\tcase 206:\n\t\treturn \"206\"\n\n\tcase 300:\n\t\treturn \"300\"\n\tcase 301:\n\t\treturn \"301\"\n\tcase 302:\n\t\treturn \"302\"\n\tcase 304:\n\t\treturn \"304\"\n\tcase 305:\n\t\treturn \"305\"\n\tcase 307:\n\t\treturn \"307\"\n\n\tcase 400:\n\t\treturn \"400\"\n\tcase 401:\n\t\treturn \"401\"\n\tcase 402:\n\t\treturn \"402\"\n\tcase 403:\n\t\treturn \"403\"\n\tcase 404:\n\t\treturn \"404\"\n\tcase 405:\n\t\treturn \"405\"\n\tcase 406:\n\t\treturn \"406\"\n\tcase 407:\n\t\treturn \"407\"\n\tcase 408:\n\t\treturn \"408\"\n\tcase 409:\n\t\treturn \"409\"\n\tcase 410:\n\t\treturn \"410\"\n\tcase 411:\n\t\treturn \"411\"\n\tcase 412:\n\t\treturn \"412\"\n\tcase 413:\n\t\treturn \"413\"\n\tcase 414:\n\t\treturn \"414\"\n\tcase 415:\n\t\treturn \"415\"\n\tcase 416:\n\t\treturn \"416\"\n\tcase 417:\n\t\treturn \"417\"\n\tcase 418:\n\t\treturn \"418\"\n\n\tcase 500:\n\t\treturn \"500\"\n\tcase 501:\n\t\treturn \"501\"\n\tcase 502:\n\t\treturn \"502\"\n\tcase 503:\n\t\treturn \"503\"\n\tcase 504:\n\t\treturn \"504\"\n\tcase 505:\n\t\treturn \"505\"\n\n\tcase 428:\n\t\treturn \"428\"\n\tcase 429:\n\t\treturn \"429\"\n\tcase 431:\n\t\treturn \"431\"\n\tcase 511:\n\t\treturn \"511\"\n\n\tdefault:\n\t\tif s >= 100 && s <= 599 {\n\t\t\treturn strconv.Itoa(s)\n\t\t}\n\t\treturn \"unknown\"\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage promhttp\n\nimport (\n\t\"context\"\n\n\t\"github.com/prometheus/client_golang/prometheus\"\n)\n\n// Option are used to configure both handler (middleware) or round tripper.\ntype Option interface {\n\tapply(*options)\n}\n\n// options store options for both a handler or round tripper.\ntype options struct {\n\textraMethods []string\n\tgetExemplarFn func(requestCtx context.Context) prometheus.Labels\n}\n\nfunc defaultOptions() *options {\n\treturn &options{getExemplarFn: func(ctx context.Context) prometheus.Labels { return nil }}\n}\n\ntype optionApplyFunc func(*options)\n\nfunc (o optionApplyFunc) apply(opt *options) { o(opt) }\n\n// WithExtraMethods adds additional HTTP methods to the list of allowed methods.\n// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods for the default list.\n//\n// See the example for ExampleInstrumentHandlerWithExtraMethods for example usage.\nfunc WithExtraMethods(methods ...string) Option {\n\treturn optionApplyFunc(func(o *options) {\n\t\to.extraMethods = methods\n\t})\n}\n\n// WithExemplarFromContext adds allows to put a hook to all counter and histogram metrics.\n// If the hook function returns non-nil labels, exemplars will be added for that request, otherwise metric\n// will get instrumented without exemplar.\nfunc WithExemplarFromContext(getExemplarFn func(requestCtx context.Context) prometheus.Labels) Option {\n\treturn optionApplyFunc(func(o *options) {\n\t\to.getExemplarFn = getExemplarFn\n\t})\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/registry.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"runtime\"\n\t\"sort\"\n\t\"strings\"\n\t\"sync\"\n\t\"unicode/utf8\"\n\n\t\"github.com/cespare/xxhash/v2\"\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\t\"github.com/prometheus/common/expfmt\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/prometheus/client_golang/prometheus/internal\"\n)\n\nconst (\n\t// Capacity for the channel to collect metrics and descriptors.\n\tcapMetricChan = 1000\n\tcapDescChan = 10\n)\n\n// DefaultRegisterer and DefaultGatherer are the implementations of the\n// Registerer and Gatherer interface a number of convenience functions in this\n// package act on. Initially, both variables point to the same Registry, which\n// has a process collector (currently on Linux only, see NewProcessCollector)\n// and a Go collector (see NewGoCollector, in particular the note about\n// stop-the-world implication with Go versions older than 1.9) already\n// registered. This approach to keep default instances as global state mirrors\n// the approach of other packages in the Go standard library. Note that there\n// are caveats. Change the variables with caution and only if you understand the\n// consequences. Users who want to avoid global state altogether should not use\n// the convenience functions and act on custom instances instead.\nvar (\n\tdefaultRegistry = NewRegistry()\n\tDefaultRegisterer Registerer = defaultRegistry\n\tDefaultGatherer Gatherer = defaultRegistry\n)\n\nfunc init() {\n\tMustRegister(NewProcessCollector(ProcessCollectorOpts{}))\n\tMustRegister(NewGoCollector())\n}\n\n// NewRegistry creates a new vanilla Registry without any Collectors\n// pre-registered.\nfunc NewRegistry() *Registry {\n\treturn &Registry{\n\t\tcollectorsByID: map[uint64]Collector{},\n\t\tdescIDs: map[uint64]struct{}{},\n\t\tdimHashesByName: map[string]uint64{},\n\t}\n}\n\n// NewPedanticRegistry returns a registry that checks during collection if each\n// collected Metric is consistent with its reported Desc, and if the Desc has\n// actually been registered with the registry. Unchecked Collectors (those whose\n// Describe method does not yield any descriptors) are excluded from the check.\n//\n// Usually, a Registry will be happy as long as the union of all collected\n// Metrics is consistent and valid even if some metrics are not consistent with\n// their own Desc or a Desc provided by their registered Collector. Well-behaved\n// Collectors and Metrics will only provide consistent Descs. This Registry is\n// useful to test the implementation of Collectors and Metrics.\nfunc NewPedanticRegistry() *Registry {\n\tr := NewRegistry()\n\tr.pedanticChecksEnabled = true\n\treturn r\n}\n\n// Registerer is the interface for the part of a registry in charge of\n// registering and unregistering. Users of custom registries should use\n// Registerer as type for registration purposes (rather than the Registry type\n// directly). In that way, they are free to use custom Registerer implementation\n// (e.g. for testing purposes).\ntype Registerer interface {\n\t// Register registers a new Collector to be included in metrics\n\t// collection. It returns an error if the descriptors provided by the\n\t// Collector are invalid or if they — in combination with descriptors of\n\t// already registered Collectors — do not fulfill the consistency and\n\t// uniqueness criteria described in the documentation of metric.Desc.\n\t//\n\t// If the provided Collector is equal to a Collector already registered\n\t// (which includes the case of re-registering the same Collector), the\n\t// returned error is an instance of AlreadyRegisteredError, which\n\t// contains the previously registered Collector.\n\t//\n\t// A Collector whose Describe method does not yield any Desc is treated\n\t// as unchecked. Registration will always succeed. No check for\n\t// re-registering (see previous paragraph) is performed. Thus, the\n\t// caller is responsible for not double-registering the same unchecked\n\t// Collector, and for providing a Collector that will not cause\n\t// inconsistent metrics on collection. (This would lead to scrape\n\t// errors.)\n\tRegister(Collector) error\n\t// MustRegister works like Register but registers any number of\n\t// Collectors and panics upon the first registration that causes an\n\t// error.\n\tMustRegister(...Collector)\n\t// Unregister unregisters the Collector that equals the Collector passed\n\t// in as an argument. (Two Collectors are considered equal if their\n\t// Describe method yields the same set of descriptors.) The function\n\t// returns whether a Collector was unregistered. Note that an unchecked\n\t// Collector cannot be unregistered (as its Describe method does not\n\t// yield any descriptor).\n\t//\n\t// Note that even after unregistering, it will not be possible to\n\t// register a new Collector that is inconsistent with the unregistered\n\t// Collector, e.g. a Collector collecting metrics with the same name but\n\t// a different help string. The rationale here is that the same registry\n\t// instance must only collect consistent metrics throughout its\n\t// lifetime.\n\tUnregister(Collector) bool\n}\n\n// Gatherer is the interface for the part of a registry in charge of gathering\n// the collected metrics into a number of MetricFamilies. The Gatherer interface\n// comes with the same general implication as described for the Registerer\n// interface.\ntype Gatherer interface {\n\t// Gather calls the Collect method of the registered Collectors and then\n\t// gathers the collected metrics into a lexicographically sorted slice\n\t// of uniquely named MetricFamily protobufs. Gather ensures that the\n\t// returned slice is valid and self-consistent so that it can be used\n\t// for valid exposition. As an exception to the strict consistency\n\t// requirements described for metric.Desc, Gather will tolerate\n\t// different sets of label names for metrics of the same metric family.\n\t//\n\t// Even if an error occurs, Gather attempts to gather as many metrics as\n\t// possible. Hence, if a non-nil error is returned, the returned\n\t// MetricFamily slice could be nil (in case of a fatal error that\n\t// prevented any meaningful metric collection) or contain a number of\n\t// MetricFamily protobufs, some of which might be incomplete, and some\n\t// might be missing altogether. The returned error (which might be a\n\t// MultiError) explains the details. Note that this is mostly useful for\n\t// debugging purposes. If the gathered protobufs are to be used for\n\t// exposition in actual monitoring, it is almost always better to not\n\t// expose an incomplete result and instead disregard the returned\n\t// MetricFamily protobufs in case the returned error is non-nil.\n\tGather() ([]*dto.MetricFamily, error)\n}\n\n// Register registers the provided Collector with the DefaultRegisterer.\n//\n// Register is a shortcut for DefaultRegisterer.Register(c). See there for more\n// details.\nfunc Register(c Collector) error {\n\treturn DefaultRegisterer.Register(c)\n}\n\n// MustRegister registers the provided Collectors with the DefaultRegisterer and\n// panics if any error occurs.\n//\n// MustRegister is a shortcut for DefaultRegisterer.MustRegister(cs...). See\n// there for more details.\nfunc MustRegister(cs ...Collector) {\n\tDefaultRegisterer.MustRegister(cs...)\n}\n\n// Unregister removes the registration of the provided Collector from the\n// DefaultRegisterer.\n//\n// Unregister is a shortcut for DefaultRegisterer.Unregister(c). See there for\n// more details.\nfunc Unregister(c Collector) bool {\n\treturn DefaultRegisterer.Unregister(c)\n}\n\n// GathererFunc turns a function into a Gatherer.\ntype GathererFunc func() ([]*dto.MetricFamily, error)\n\n// Gather implements Gatherer.\nfunc (gf GathererFunc) Gather() ([]*dto.MetricFamily, error) {\n\treturn gf()\n}\n\n// AlreadyRegisteredError is returned by the Register method if the Collector to\n// be registered has already been registered before, or a different Collector\n// that collects the same metrics has been registered before. Registration fails\n// in that case, but you can detect from the kind of error what has\n// happened. The error contains fields for the existing Collector and the\n// (rejected) new Collector that equals the existing one. This can be used to\n// find out if an equal Collector has been registered before and switch over to\n// using the old one, as demonstrated in the example.\ntype AlreadyRegisteredError struct {\n\tExistingCollector, NewCollector Collector\n}\n\nfunc (err AlreadyRegisteredError) Error() string {\n\treturn \"duplicate metrics collector registration attempted\"\n}\n\n// MultiError is a slice of errors implementing the error interface. It is used\n// by a Gatherer to report multiple errors during MetricFamily gathering.\ntype MultiError []error\n\n// Error formats the contained errors as a bullet point list, preceded by the\n// total number of errors. Note that this results in a multi-line string.\nfunc (errs MultiError) Error() string {\n\tif len(errs) == 0 {\n\t\treturn \"\"\n\t}\n\tbuf := &bytes.Buffer{}\n\tfmt.Fprintf(buf, \"%d error(s) occurred:\", len(errs))\n\tfor _, err := range errs {\n\t\tfmt.Fprintf(buf, \"\\n* %s\", err)\n\t}\n\treturn buf.String()\n}\n\n// Append appends the provided error if it is not nil.\nfunc (errs *MultiError) Append(err error) {\n\tif err != nil {\n\t\t*errs = append(*errs, err)\n\t}\n}\n\n// MaybeUnwrap returns nil if len(errs) is 0. It returns the first and only\n// contained error as error if len(errs is 1). In all other cases, it returns\n// the MultiError directly. This is helpful for returning a MultiError in a way\n// that only uses the MultiError if needed.\nfunc (errs MultiError) MaybeUnwrap() error {\n\tswitch len(errs) {\n\tcase 0:\n\t\treturn nil\n\tcase 1:\n\t\treturn errs[0]\n\tdefault:\n\t\treturn errs\n\t}\n}\n\n// Registry registers Prometheus collectors, collects their metrics, and gathers\n// them into MetricFamilies for exposition. It implements Registerer, Gatherer,\n// and Collector. The zero value is not usable. Create instances with\n// NewRegistry or NewPedanticRegistry.\n//\n// Registry implements Collector to allow it to be used for creating groups of\n// metrics. See the Grouping example for how this can be done.\ntype Registry struct {\n\tmtx sync.RWMutex\n\tcollectorsByID map[uint64]Collector // ID is a hash of the descIDs.\n\tdescIDs map[uint64]struct{}\n\tdimHashesByName map[string]uint64\n\tuncheckedCollectors []Collector\n\tpedanticChecksEnabled bool\n}\n\n// Register implements Registerer.\nfunc (r *Registry) Register(c Collector) error {\n\tvar (\n\t\tdescChan = make(chan *Desc, capDescChan)\n\t\tnewDescIDs = map[uint64]struct{}{}\n\t\tnewDimHashesByName = map[string]uint64{}\n\t\tcollectorID uint64 // All desc IDs XOR'd together.\n\t\tduplicateDescErr error\n\t)\n\tgo func() {\n\t\tc.Describe(descChan)\n\t\tclose(descChan)\n\t}()\n\tr.mtx.Lock()\n\tdefer func() {\n\t\t// Drain channel in case of premature return to not leak a goroutine.\n\t\tfor range descChan {\n\t\t}\n\t\tr.mtx.Unlock()\n\t}()\n\t// Conduct various tests...\n\tfor desc := range descChan {\n\n\t\t// Is the descriptor valid at all?\n\t\tif desc.err != nil {\n\t\t\treturn fmt.Errorf(\"descriptor %s is invalid: %w\", desc, desc.err)\n\t\t}\n\n\t\t// Is the descID unique?\n\t\t// (In other words: Is the fqName + constLabel combination unique?)\n\t\tif _, exists := r.descIDs[desc.id]; exists {\n\t\t\tduplicateDescErr = fmt.Errorf(\"descriptor %s already exists with the same fully-qualified name and const label values\", desc)\n\t\t}\n\t\t// If it is not a duplicate desc in this collector, XOR it to\n\t\t// the collectorID. (We allow duplicate descs within the same\n\t\t// collector, but their existence must be a no-op.)\n\t\tif _, exists := newDescIDs[desc.id]; !exists {\n\t\t\tnewDescIDs[desc.id] = struct{}{}\n\t\t\tcollectorID ^= desc.id\n\t\t}\n\n\t\t// Are all the label names and the help string consistent with\n\t\t// previous descriptors of the same name?\n\t\t// First check existing descriptors...\n\t\tif dimHash, exists := r.dimHashesByName[desc.fqName]; exists {\n\t\t\tif dimHash != desc.dimHash {\n\t\t\t\treturn fmt.Errorf(\"a previously registered descriptor with the same fully-qualified name as %s has different label names or a different help string\", desc)\n\t\t\t}\n\t\t} else {\n\t\t\t// ...then check the new descriptors already seen.\n\t\t\tif dimHash, exists := newDimHashesByName[desc.fqName]; exists {\n\t\t\t\tif dimHash != desc.dimHash {\n\t\t\t\t\treturn fmt.Errorf(\"descriptors reported by collector have inconsistent label names or help strings for the same fully-qualified name, offender is %s\", desc)\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tnewDimHashesByName[desc.fqName] = desc.dimHash\n\t\t\t}\n\t\t}\n\t}\n\t// A Collector yielding no Desc at all is considered unchecked.\n\tif len(newDescIDs) == 0 {\n\t\tr.uncheckedCollectors = append(r.uncheckedCollectors, c)\n\t\treturn nil\n\t}\n\tif existing, exists := r.collectorsByID[collectorID]; exists {\n\t\tswitch e := existing.(type) {\n\t\tcase *wrappingCollector:\n\t\t\treturn AlreadyRegisteredError{\n\t\t\t\tExistingCollector: e.unwrapRecursively(),\n\t\t\t\tNewCollector: c,\n\t\t\t}\n\t\tdefault:\n\t\t\treturn AlreadyRegisteredError{\n\t\t\t\tExistingCollector: e,\n\t\t\t\tNewCollector: c,\n\t\t\t}\n\t\t}\n\t}\n\t// If the collectorID is new, but at least one of the descs existed\n\t// before, we are in trouble.\n\tif duplicateDescErr != nil {\n\t\treturn duplicateDescErr\n\t}\n\n\t// Only after all tests have passed, actually register.\n\tr.collectorsByID[collectorID] = c\n\tfor hash := range newDescIDs {\n\t\tr.descIDs[hash] = struct{}{}\n\t}\n\tfor name, dimHash := range newDimHashesByName {\n\t\tr.dimHashesByName[name] = dimHash\n\t}\n\treturn nil\n}\n\n// Unregister implements Registerer.\nfunc (r *Registry) Unregister(c Collector) bool {\n\tvar (\n\t\tdescChan = make(chan *Desc, capDescChan)\n\t\tdescIDs = map[uint64]struct{}{}\n\t\tcollectorID uint64 // All desc IDs XOR'd together.\n\t)\n\tgo func() {\n\t\tc.Describe(descChan)\n\t\tclose(descChan)\n\t}()\n\tfor desc := range descChan {\n\t\tif _, exists := descIDs[desc.id]; !exists {\n\t\t\tcollectorID ^= desc.id\n\t\t\tdescIDs[desc.id] = struct{}{}\n\t\t}\n\t}\n\n\tr.mtx.RLock()\n\tif _, exists := r.collectorsByID[collectorID]; !exists {\n\t\tr.mtx.RUnlock()\n\t\treturn false\n\t}\n\tr.mtx.RUnlock()\n\n\tr.mtx.Lock()\n\tdefer r.mtx.Unlock()\n\n\tdelete(r.collectorsByID, collectorID)\n\tfor id := range descIDs {\n\t\tdelete(r.descIDs, id)\n\t}\n\t// dimHashesByName is left untouched as those must be consistent\n\t// throughout the lifetime of a program.\n\treturn true\n}\n\n// MustRegister implements Registerer.\nfunc (r *Registry) MustRegister(cs ...Collector) {\n\tfor _, c := range cs {\n\t\tif err := r.Register(c); err != nil {\n\t\t\tpanic(err)\n\t\t}\n\t}\n}\n\n// Gather implements Gatherer.\nfunc (r *Registry) Gather() ([]*dto.MetricFamily, error) {\n\tr.mtx.RLock()\n\n\tif len(r.collectorsByID) == 0 && len(r.uncheckedCollectors) == 0 {\n\t\t// Fast path.\n\t\tr.mtx.RUnlock()\n\t\treturn nil, nil\n\t}\n\n\tvar (\n\t\tcheckedMetricChan = make(chan Metric, capMetricChan)\n\t\tuncheckedMetricChan = make(chan Metric, capMetricChan)\n\t\tmetricHashes = map[uint64]struct{}{}\n\t\twg sync.WaitGroup\n\t\terrs MultiError // The collected errors to return in the end.\n\t\tregisteredDescIDs map[uint64]struct{} // Only used for pedantic checks\n\t)\n\n\tgoroutineBudget := len(r.collectorsByID) + len(r.uncheckedCollectors)\n\tmetricFamiliesByName := make(map[string]*dto.MetricFamily, len(r.dimHashesByName))\n\tcheckedCollectors := make(chan Collector, len(r.collectorsByID))\n\tuncheckedCollectors := make(chan Collector, len(r.uncheckedCollectors))\n\tfor _, collector := range r.collectorsByID {\n\t\tcheckedCollectors <- collector\n\t}\n\tfor _, collector := range r.uncheckedCollectors {\n\t\tuncheckedCollectors <- collector\n\t}\n\t// In case pedantic checks are enabled, we have to copy the map before\n\t// giving up the RLock.\n\tif r.pedanticChecksEnabled {\n\t\tregisteredDescIDs = make(map[uint64]struct{}, len(r.descIDs))\n\t\tfor id := range r.descIDs {\n\t\t\tregisteredDescIDs[id] = struct{}{}\n\t\t}\n\t}\n\tr.mtx.RUnlock()\n\n\twg.Add(goroutineBudget)\n\n\tcollectWorker := func() {\n\t\tfor {\n\t\t\tselect {\n\t\t\tcase collector := <-checkedCollectors:\n\t\t\t\tcollector.Collect(checkedMetricChan)\n\t\t\tcase collector := <-uncheckedCollectors:\n\t\t\t\tcollector.Collect(uncheckedMetricChan)\n\t\t\tdefault:\n\t\t\t\treturn\n\t\t\t}\n\t\t\twg.Done()\n\t\t}\n\t}\n\n\t// Start the first worker now to make sure at least one is running.\n\tgo collectWorker()\n\tgoroutineBudget--\n\n\t// Close checkedMetricChan and uncheckedMetricChan once all collectors\n\t// are collected.\n\tgo func() {\n\t\twg.Wait()\n\t\tclose(checkedMetricChan)\n\t\tclose(uncheckedMetricChan)\n\t}()\n\n\t// Drain checkedMetricChan and uncheckedMetricChan in case of premature return.\n\tdefer func() {\n\t\tif checkedMetricChan != nil {\n\t\t\tfor range checkedMetricChan {\n\t\t\t}\n\t\t}\n\t\tif uncheckedMetricChan != nil {\n\t\t\tfor range uncheckedMetricChan {\n\t\t\t}\n\t\t}\n\t}()\n\n\t// Copy the channel references so we can nil them out later to remove\n\t// them from the select statements below.\n\tcmc := checkedMetricChan\n\tumc := uncheckedMetricChan\n\n\tfor {\n\t\tselect {\n\t\tcase metric, ok := <-cmc:\n\t\t\tif !ok {\n\t\t\t\tcmc = nil\n\t\t\t\tbreak\n\t\t\t}\n\t\t\terrs.Append(processMetric(\n\t\t\t\tmetric, metricFamiliesByName,\n\t\t\t\tmetricHashes,\n\t\t\t\tregisteredDescIDs,\n\t\t\t))\n\t\tcase metric, ok := <-umc:\n\t\t\tif !ok {\n\t\t\t\tumc = nil\n\t\t\t\tbreak\n\t\t\t}\n\t\t\terrs.Append(processMetric(\n\t\t\t\tmetric, metricFamiliesByName,\n\t\t\t\tmetricHashes,\n\t\t\t\tnil,\n\t\t\t))\n\t\tdefault:\n\t\t\tif goroutineBudget <= 0 || len(checkedCollectors)+len(uncheckedCollectors) == 0 {\n\t\t\t\t// All collectors are already being worked on or\n\t\t\t\t// we have already as many goroutines started as\n\t\t\t\t// there are collectors. Do the same as above,\n\t\t\t\t// just without the default.\n\t\t\t\tselect {\n\t\t\t\tcase metric, ok := <-cmc:\n\t\t\t\t\tif !ok {\n\t\t\t\t\t\tcmc = nil\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\terrs.Append(processMetric(\n\t\t\t\t\t\tmetric, metricFamiliesByName,\n\t\t\t\t\t\tmetricHashes,\n\t\t\t\t\t\tregisteredDescIDs,\n\t\t\t\t\t))\n\t\t\t\tcase metric, ok := <-umc:\n\t\t\t\t\tif !ok {\n\t\t\t\t\t\tumc = nil\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\terrs.Append(processMetric(\n\t\t\t\t\t\tmetric, metricFamiliesByName,\n\t\t\t\t\t\tmetricHashes,\n\t\t\t\t\t\tnil,\n\t\t\t\t\t))\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t// Start more workers.\n\t\t\tgo collectWorker()\n\t\t\tgoroutineBudget--\n\t\t\truntime.Gosched()\n\t\t}\n\t\t// Once both checkedMetricChan and uncheckdMetricChan are closed\n\t\t// and drained, the contraption above will nil out cmc and umc,\n\t\t// and then we can leave the collect loop here.\n\t\tif cmc == nil && umc == nil {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()\n}\n\n// Describe implements Collector.\nfunc (r *Registry) Describe(ch chan<- *Desc) {\n\tr.mtx.RLock()\n\tdefer r.mtx.RUnlock()\n\n\t// Only report the checked Collectors; unchecked collectors don't report any\n\t// Desc.\n\tfor _, c := range r.collectorsByID {\n\t\tc.Describe(ch)\n\t}\n}\n\n// Collect implements Collector.\nfunc (r *Registry) Collect(ch chan<- Metric) {\n\tr.mtx.RLock()\n\tdefer r.mtx.RUnlock()\n\n\tfor _, c := range r.collectorsByID {\n\t\tc.Collect(ch)\n\t}\n\tfor _, c := range r.uncheckedCollectors {\n\t\tc.Collect(ch)\n\t}\n}\n\n// WriteToTextfile calls Gather on the provided Gatherer, encodes the result in the\n// Prometheus text format, and writes it to a temporary file. Upon success, the\n// temporary file is renamed to the provided filename.\n//\n// This is intended for use with the textfile collector of the node exporter.\n// Note that the node exporter expects the filename to be suffixed with \".prom\".\nfunc WriteToTextfile(filename string, g Gatherer) error {\n\ttmp, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))\n\tif err != nil {\n\t\treturn err\n\t}\n\tdefer os.Remove(tmp.Name())\n\n\tmfs, err := g.Gather()\n\tif err != nil {\n\t\treturn err\n\t}\n\tfor _, mf := range mfs {\n\t\tif _, err := expfmt.MetricFamilyToText(tmp, mf); err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tif err := tmp.Close(); err != nil {\n\t\treturn err\n\t}\n\n\tif err := os.Chmod(tmp.Name(), 0o644); err != nil {\n\t\treturn err\n\t}\n\treturn os.Rename(tmp.Name(), filename)\n}\n\n// processMetric is an internal helper method only used by the Gather method.\nfunc processMetric(\n\tmetric Metric,\n\tmetricFamiliesByName map[string]*dto.MetricFamily,\n\tmetricHashes map[uint64]struct{},\n\tregisteredDescIDs map[uint64]struct{},\n) error {\n\tdesc := metric.Desc()\n\t// Wrapped metrics collected by an unchecked Collector can have an\n\t// invalid Desc.\n\tif desc.err != nil {\n\t\treturn desc.err\n\t}\n\tdtoMetric := &dto.Metric{}\n\tif err := metric.Write(dtoMetric); err != nil {\n\t\treturn fmt.Errorf(\"error collecting metric %v: %w\", desc, err)\n\t}\n\tmetricFamily, ok := metricFamiliesByName[desc.fqName]\n\tif ok { // Existing name.\n\t\tif metricFamily.GetHelp() != desc.help {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %s %s has help %q but should have %q\",\n\t\t\t\tdesc.fqName, dtoMetric, desc.help, metricFamily.GetHelp(),\n\t\t\t)\n\t\t}\n\t\t// TODO(beorn7): Simplify switch once Desc has type.\n\t\tswitch metricFamily.GetType() {\n\t\tcase dto.MetricType_COUNTER:\n\t\t\tif dtoMetric.Counter == nil {\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric %s %s should be a Counter\",\n\t\t\t\t\tdesc.fqName, dtoMetric,\n\t\t\t\t)\n\t\t\t}\n\t\tcase dto.MetricType_GAUGE:\n\t\t\tif dtoMetric.Gauge == nil {\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric %s %s should be a Gauge\",\n\t\t\t\t\tdesc.fqName, dtoMetric,\n\t\t\t\t)\n\t\t\t}\n\t\tcase dto.MetricType_SUMMARY:\n\t\t\tif dtoMetric.Summary == nil {\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric %s %s should be a Summary\",\n\t\t\t\t\tdesc.fqName, dtoMetric,\n\t\t\t\t)\n\t\t\t}\n\t\tcase dto.MetricType_UNTYPED:\n\t\t\tif dtoMetric.Untyped == nil {\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric %s %s should be Untyped\",\n\t\t\t\t\tdesc.fqName, dtoMetric,\n\t\t\t\t)\n\t\t\t}\n\t\tcase dto.MetricType_HISTOGRAM:\n\t\t\tif dtoMetric.Histogram == nil {\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric %s %s should be a Histogram\",\n\t\t\t\t\tdesc.fqName, dtoMetric,\n\t\t\t\t)\n\t\t\t}\n\t\tdefault:\n\t\t\tpanic(\"encountered MetricFamily with invalid type\")\n\t\t}\n\t} else { // New name.\n\t\tmetricFamily = &dto.MetricFamily{}\n\t\tmetricFamily.Name = proto.String(desc.fqName)\n\t\tmetricFamily.Help = proto.String(desc.help)\n\t\t// TODO(beorn7): Simplify switch once Desc has type.\n\t\tswitch {\n\t\tcase dtoMetric.Gauge != nil:\n\t\t\tmetricFamily.Type = dto.MetricType_GAUGE.Enum()\n\t\tcase dtoMetric.Counter != nil:\n\t\t\tmetricFamily.Type = dto.MetricType_COUNTER.Enum()\n\t\tcase dtoMetric.Summary != nil:\n\t\t\tmetricFamily.Type = dto.MetricType_SUMMARY.Enum()\n\t\tcase dtoMetric.Untyped != nil:\n\t\t\tmetricFamily.Type = dto.MetricType_UNTYPED.Enum()\n\t\tcase dtoMetric.Histogram != nil:\n\t\t\tmetricFamily.Type = dto.MetricType_HISTOGRAM.Enum()\n\t\tdefault:\n\t\t\treturn fmt.Errorf(\"empty metric collected: %s\", dtoMetric)\n\t\t}\n\t\tif err := checkSuffixCollisions(metricFamily, metricFamiliesByName); err != nil {\n\t\t\treturn err\n\t\t}\n\t\tmetricFamiliesByName[desc.fqName] = metricFamily\n\t}\n\tif err := checkMetricConsistency(metricFamily, dtoMetric, metricHashes); err != nil {\n\t\treturn err\n\t}\n\tif registeredDescIDs != nil {\n\t\t// Is the desc registered at all?\n\t\tif _, exist := registeredDescIDs[desc.id]; !exist {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %s %s with unregistered descriptor %s\",\n\t\t\t\tmetricFamily.GetName(), dtoMetric, desc,\n\t\t\t)\n\t\t}\n\t\tif err := checkDescConsistency(metricFamily, dtoMetric, desc); err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tmetricFamily.Metric = append(metricFamily.Metric, dtoMetric)\n\treturn nil\n}\n\n// Gatherers is a slice of Gatherer instances that implements the Gatherer\n// interface itself. Its Gather method calls Gather on all Gatherers in the\n// slice in order and returns the merged results. Errors returned from the\n// Gather calls are all returned in a flattened MultiError. Duplicate and\n// inconsistent Metrics are skipped (first occurrence in slice order wins) and\n// reported in the returned error.\n//\n// Gatherers can be used to merge the Gather results from multiple\n// Registries. It also provides a way to directly inject existing MetricFamily\n// protobufs into the gathering by creating a custom Gatherer with a Gather\n// method that simply returns the existing MetricFamily protobufs. Note that no\n// registration is involved (in contrast to Collector registration), so\n// obviously registration-time checks cannot happen. Any inconsistencies between\n// the gathered MetricFamilies are reported as errors by the Gather method, and\n// inconsistent Metrics are dropped. Invalid parts of the MetricFamilies\n// (e.g. syntactically invalid metric or label names) will go undetected.\ntype Gatherers []Gatherer\n\n// Gather implements Gatherer.\nfunc (gs Gatherers) Gather() ([]*dto.MetricFamily, error) {\n\tvar (\n\t\tmetricFamiliesByName = map[string]*dto.MetricFamily{}\n\t\tmetricHashes = map[uint64]struct{}{}\n\t\terrs MultiError // The collected errors to return in the end.\n\t)\n\n\tfor i, g := range gs {\n\t\tmfs, err := g.Gather()\n\t\tif err != nil {\n\t\t\tmultiErr := MultiError{}\n\t\t\tif errors.As(err, &multiErr) {\n\t\t\t\tfor _, err := range multiErr {\n\t\t\t\t\terrs = append(errs, fmt.Errorf(\"[from Gatherer #%d] %w\", i+1, err))\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terrs = append(errs, fmt.Errorf(\"[from Gatherer #%d] %w\", i+1, err))\n\t\t\t}\n\t\t}\n\t\tfor _, mf := range mfs {\n\t\t\texistingMF, exists := metricFamiliesByName[mf.GetName()]\n\t\t\tif exists {\n\t\t\t\tif existingMF.GetHelp() != mf.GetHelp() {\n\t\t\t\t\terrs = append(errs, fmt.Errorf(\n\t\t\t\t\t\t\"gathered metric family %s has help %q but should have %q\",\n\t\t\t\t\t\tmf.GetName(), mf.GetHelp(), existingMF.GetHelp(),\n\t\t\t\t\t))\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tif existingMF.GetType() != mf.GetType() {\n\t\t\t\t\terrs = append(errs, fmt.Errorf(\n\t\t\t\t\t\t\"gathered metric family %s has type %s but should have %s\",\n\t\t\t\t\t\tmf.GetName(), mf.GetType(), existingMF.GetType(),\n\t\t\t\t\t))\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\texistingMF = &dto.MetricFamily{}\n\t\t\t\texistingMF.Name = mf.Name\n\t\t\t\texistingMF.Help = mf.Help\n\t\t\t\texistingMF.Type = mf.Type\n\t\t\t\tif err := checkSuffixCollisions(existingMF, metricFamiliesByName); err != nil {\n\t\t\t\t\terrs = append(errs, err)\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tmetricFamiliesByName[mf.GetName()] = existingMF\n\t\t\t}\n\t\t\tfor _, m := range mf.Metric {\n\t\t\t\tif err := checkMetricConsistency(existingMF, m, metricHashes); err != nil {\n\t\t\t\t\terrs = append(errs, err)\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\texistingMF.Metric = append(existingMF.Metric, m)\n\t\t\t}\n\t\t}\n\t}\n\treturn internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()\n}\n\n// checkSuffixCollisions checks for collisions with the “magic” suffixes the\n// Prometheus text format and the internal metric representation of the\n// Prometheus server add while flattening Summaries and Histograms.\nfunc checkSuffixCollisions(mf *dto.MetricFamily, mfs map[string]*dto.MetricFamily) error {\n\tvar (\n\t\tnewName = mf.GetName()\n\t\tnewType = mf.GetType()\n\t\tnewNameWithoutSuffix = \"\"\n\t)\n\tswitch {\n\tcase strings.HasSuffix(newName, \"_count\"):\n\t\tnewNameWithoutSuffix = newName[:len(newName)-6]\n\tcase strings.HasSuffix(newName, \"_sum\"):\n\t\tnewNameWithoutSuffix = newName[:len(newName)-4]\n\tcase strings.HasSuffix(newName, \"_bucket\"):\n\t\tnewNameWithoutSuffix = newName[:len(newName)-7]\n\t}\n\tif newNameWithoutSuffix != \"\" {\n\t\tif existingMF, ok := mfs[newNameWithoutSuffix]; ok {\n\t\t\tswitch existingMF.GetType() {\n\t\t\tcase dto.MetricType_SUMMARY:\n\t\t\t\tif !strings.HasSuffix(newName, \"_bucket\") {\n\t\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\t\"collected metric named %q collides with previously collected summary named %q\",\n\t\t\t\t\t\tnewName, newNameWithoutSuffix,\n\t\t\t\t\t)\n\t\t\t\t}\n\t\t\tcase dto.MetricType_HISTOGRAM:\n\t\t\t\treturn fmt.Errorf(\n\t\t\t\t\t\"collected metric named %q collides with previously collected histogram named %q\",\n\t\t\t\t\tnewName, newNameWithoutSuffix,\n\t\t\t\t)\n\t\t\t}\n\t\t}\n\t}\n\tif newType == dto.MetricType_SUMMARY || newType == dto.MetricType_HISTOGRAM {\n\t\tif _, ok := mfs[newName+\"_count\"]; ok {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected histogram or summary named %q collides with previously collected metric named %q\",\n\t\t\t\tnewName, newName+\"_count\",\n\t\t\t)\n\t\t}\n\t\tif _, ok := mfs[newName+\"_sum\"]; ok {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected histogram or summary named %q collides with previously collected metric named %q\",\n\t\t\t\tnewName, newName+\"_sum\",\n\t\t\t)\n\t\t}\n\t}\n\tif newType == dto.MetricType_HISTOGRAM {\n\t\tif _, ok := mfs[newName+\"_bucket\"]; ok {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected histogram named %q collides with previously collected metric named %q\",\n\t\t\t\tnewName, newName+\"_bucket\",\n\t\t\t)\n\t\t}\n\t}\n\treturn nil\n}\n\n// checkMetricConsistency checks if the provided Metric is consistent with the\n// provided MetricFamily. It also hashes the Metric labels and the MetricFamily\n// name. If the resulting hash is already in the provided metricHashes, an error\n// is returned. If not, it is added to metricHashes.\nfunc checkMetricConsistency(\n\tmetricFamily *dto.MetricFamily,\n\tdtoMetric *dto.Metric,\n\tmetricHashes map[uint64]struct{},\n) error {\n\tname := metricFamily.GetName()\n\n\t// Type consistency with metric family.\n\tif metricFamily.GetType() == dto.MetricType_GAUGE && dtoMetric.Gauge == nil ||\n\t\tmetricFamily.GetType() == dto.MetricType_COUNTER && dtoMetric.Counter == nil ||\n\t\tmetricFamily.GetType() == dto.MetricType_SUMMARY && dtoMetric.Summary == nil ||\n\t\tmetricFamily.GetType() == dto.MetricType_HISTOGRAM && dtoMetric.Histogram == nil ||\n\t\tmetricFamily.GetType() == dto.MetricType_UNTYPED && dtoMetric.Untyped == nil {\n\t\treturn fmt.Errorf(\n\t\t\t\"collected metric %q { %s} is not a %s\",\n\t\t\tname, dtoMetric, metricFamily.GetType(),\n\t\t)\n\t}\n\n\tpreviousLabelName := \"\"\n\tfor _, labelPair := range dtoMetric.GetLabel() {\n\t\tlabelName := labelPair.GetName()\n\t\tif labelName == previousLabelName {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %q { %s} has two or more labels with the same name: %s\",\n\t\t\t\tname, dtoMetric, labelName,\n\t\t\t)\n\t\t}\n\t\tif !checkLabelName(labelName) {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %q { %s} has a label with an invalid name: %s\",\n\t\t\t\tname, dtoMetric, labelName,\n\t\t\t)\n\t\t}\n\t\tif dtoMetric.Summary != nil && labelName == quantileLabel {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %q { %s} must not have an explicit %q label\",\n\t\t\t\tname, dtoMetric, quantileLabel,\n\t\t\t)\n\t\t}\n\t\tif !utf8.ValidString(labelPair.GetValue()) {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"collected metric %q { %s} has a label named %q whose value is not utf8: %#v\",\n\t\t\t\tname, dtoMetric, labelName, labelPair.GetValue())\n\t\t}\n\t\tpreviousLabelName = labelName\n\t}\n\n\t// Is the metric unique (i.e. no other metric with the same name and the same labels)?\n\th := xxhash.New()\n\th.WriteString(name)\n\th.Write(separatorByteSlice)\n\t// Make sure label pairs are sorted. We depend on it for the consistency\n\t// check.\n\tif !sort.IsSorted(internal.LabelPairSorter(dtoMetric.Label)) {\n\t\t// We cannot sort dtoMetric.Label in place as it is immutable by contract.\n\t\tcopiedLabels := make([]*dto.LabelPair, len(dtoMetric.Label))\n\t\tcopy(copiedLabels, dtoMetric.Label)\n\t\tsort.Sort(internal.LabelPairSorter(copiedLabels))\n\t\tdtoMetric.Label = copiedLabels\n\t}\n\tfor _, lp := range dtoMetric.Label {\n\t\th.WriteString(lp.GetName())\n\t\th.Write(separatorByteSlice)\n\t\th.WriteString(lp.GetValue())\n\t\th.Write(separatorByteSlice)\n\t}\n\thSum := h.Sum64()\n\tif _, exists := metricHashes[hSum]; exists {\n\t\treturn fmt.Errorf(\n\t\t\t\"collected metric %q { %s} was collected before with the same name and label values\",\n\t\t\tname, dtoMetric,\n\t\t)\n\t}\n\tmetricHashes[hSum] = struct{}{}\n\treturn nil\n}\n\nfunc checkDescConsistency(\n\tmetricFamily *dto.MetricFamily,\n\tdtoMetric *dto.Metric,\n\tdesc *Desc,\n) error {\n\t// Desc help consistency with metric family help.\n\tif metricFamily.GetHelp() != desc.help {\n\t\treturn fmt.Errorf(\n\t\t\t\"collected metric %s %s has help %q but should have %q\",\n\t\t\tmetricFamily.GetName(), dtoMetric, metricFamily.GetHelp(), desc.help,\n\t\t)\n\t}\n\n\t// Is the desc consistent with the content of the metric?\n\tlpsFromDesc := make([]*dto.LabelPair, len(desc.constLabelPairs), len(dtoMetric.Label))\n\tcopy(lpsFromDesc, desc.constLabelPairs)\n\tfor _, l := range desc.variableLabels {\n\t\tlpsFromDesc = append(lpsFromDesc, &dto.LabelPair{\n\t\t\tName: proto.String(l),\n\t\t})\n\t}\n\tif len(lpsFromDesc) != len(dtoMetric.Label) {\n\t\treturn fmt.Errorf(\n\t\t\t\"labels in collected metric %s %s are inconsistent with descriptor %s\",\n\t\t\tmetricFamily.GetName(), dtoMetric, desc,\n\t\t)\n\t}\n\tsort.Sort(internal.LabelPairSorter(lpsFromDesc))\n\tfor i, lpFromDesc := range lpsFromDesc {\n\t\tlpFromMetric := dtoMetric.Label[i]\n\t\tif lpFromDesc.GetName() != lpFromMetric.GetName() ||\n\t\t\tlpFromDesc.Value != nil && lpFromDesc.GetValue() != lpFromMetric.GetValue() {\n\t\t\treturn fmt.Errorf(\n\t\t\t\t\"labels in collected metric %s %s are inconsistent with descriptor %s\",\n\t\t\t\tmetricFamily.GetName(), dtoMetric, desc,\n\t\t\t)\n\t\t}\n\t}\n\treturn nil\n}\n\nvar _ TransactionalGatherer = &MultiTRegistry{}\n\n// MultiTRegistry is a TransactionalGatherer that joins gathered metrics from multiple\n// transactional gatherers.\n//\n// It is caller responsibility to ensure two registries have mutually exclusive metric families,\n// no deduplication will happen.\ntype MultiTRegistry struct {\n\ttGatherers []TransactionalGatherer\n}\n\n// NewMultiTRegistry creates MultiTRegistry.\nfunc NewMultiTRegistry(tGatherers ...TransactionalGatherer) *MultiTRegistry {\n\treturn &MultiTRegistry{\n\t\ttGatherers: tGatherers,\n\t}\n}\n\n// Gather implements TransactionalGatherer interface.\nfunc (r *MultiTRegistry) Gather() (mfs []*dto.MetricFamily, done func(), err error) {\n\terrs := MultiError{}\n\n\tdFns := make([]func(), 0, len(r.tGatherers))\n\t// TODO(bwplotka): Implement concurrency for those?\n\tfor _, g := range r.tGatherers {\n\t\t// TODO(bwplotka): Check for duplicates?\n\t\tm, d, err := g.Gather()\n\t\terrs.Append(err)\n\n\t\tmfs = append(mfs, m...)\n\t\tdFns = append(dFns, d)\n\t}\n\n\t// TODO(bwplotka): Consider sort in place, given metric family in gather is sorted already.\n\tsort.Slice(mfs, func(i, j int) bool {\n\t\treturn *mfs[i].Name < *mfs[j].Name\n\t})\n\treturn mfs, func() {\n\t\tfor _, d := range dFns {\n\t\t\td()\n\t\t}\n\t}, errs.MaybeUnwrap()\n}\n\n// TransactionalGatherer represents transactional gatherer that can be triggered to notify gatherer that memory\n// used by metric family is no longer used by a caller. This allows implementations with cache.\ntype TransactionalGatherer interface {\n\t// Gather returns metrics in a lexicographically sorted slice\n\t// of uniquely named MetricFamily protobufs. Gather ensures that the\n\t// returned slice is valid and self-consistent so that it can be used\n\t// for valid exposition. As an exception to the strict consistency\n\t// requirements described for metric.Desc, Gather will tolerate\n\t// different sets of label names for metrics of the same metric family.\n\t//\n\t// Even if an error occurs, Gather attempts to gather as many metrics as\n\t// possible. Hence, if a non-nil error is returned, the returned\n\t// MetricFamily slice could be nil (in case of a fatal error that\n\t// prevented any meaningful metric collection) or contain a number of\n\t// MetricFamily protobufs, some of which might be incomplete, and some\n\t// might be missing altogether. The returned error (which might be a\n\t// MultiError) explains the details. Note that this is mostly useful for\n\t// debugging purposes. If the gathered protobufs are to be used for\n\t// exposition in actual monitoring, it is almost always better to not\n\t// expose an incomplete result and instead disregard the returned\n\t// MetricFamily protobufs in case the returned error is non-nil.\n\t//\n\t// Important: done is expected to be triggered (even if the error occurs!)\n\t// once caller does not need returned slice of dto.MetricFamily.\n\tGather() (_ []*dto.MetricFamily, done func(), err error)\n}\n\n// ToTransactionalGatherer transforms Gatherer to transactional one with noop as done function.\nfunc ToTransactionalGatherer(g Gatherer) TransactionalGatherer {\n\treturn &noTransactionGatherer{g: g}\n}\n\ntype noTransactionGatherer struct {\n\tg Gatherer\n}\n\n// Gather implements TransactionalGatherer interface.\nfunc (g *noTransactionGatherer) Gather() (_ []*dto.MetricFamily, done func(), err error) {\n\tmfs, err := g.g.Gather()\n\treturn mfs, func() {}, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/summary.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"runtime\"\n\t\"sort\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\t\"github.com/beorn7/perks/quantile\"\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// quantileLabel is used for the label that defines the quantile in a\n// summary.\nconst quantileLabel = \"quantile\"\n\n// A Summary captures individual observations from an event or sample stream and\n// summarizes them in a manner similar to traditional summary statistics: 1. sum\n// of observations, 2. observation count, 3. rank estimations.\n//\n// A typical use-case is the observation of request latencies. By default, a\n// Summary provides the median, the 90th and the 99th percentile of the latency\n// as rank estimations. However, the default behavior will change in the\n// upcoming v1.0.0 of the library. There will be no rank estimations at all by\n// default. For a sane transition, it is recommended to set the desired rank\n// estimations explicitly.\n//\n// Note that the rank estimations cannot be aggregated in a meaningful way with\n// the Prometheus query language (i.e. you cannot average or add them). If you\n// need aggregatable quantiles (e.g. you want the 99th percentile latency of all\n// queries served across all instances of a service), consider the Histogram\n// metric type. See the Prometheus documentation for more details.\n//\n// To create Summary instances, use NewSummary.\ntype Summary interface {\n\tMetric\n\tCollector\n\n\t// Observe adds a single observation to the summary. Observations are\n\t// usually positive or zero. Negative observations are accepted but\n\t// prevent current versions of Prometheus from properly detecting\n\t// counter resets in the sum of observations. See\n\t// https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations\n\t// for details.\n\tObserve(float64)\n}\n\nvar errQuantileLabelNotAllowed = fmt.Errorf(\n\t\"%q is not allowed as label name in summaries\", quantileLabel,\n)\n\n// Default values for SummaryOpts.\nconst (\n\t// DefMaxAge is the default duration for which observations stay\n\t// relevant.\n\tDefMaxAge time.Duration = 10 * time.Minute\n\t// DefAgeBuckets is the default number of buckets used to calculate the\n\t// age of observations.\n\tDefAgeBuckets = 5\n\t// DefBufCap is the standard buffer size for collecting Summary observations.\n\tDefBufCap = 500\n)\n\n// SummaryOpts bundles the options for creating a Summary metric. It is\n// mandatory to set Name to a non-empty string. While all other fields are\n// optional and can safely be left at their zero value, it is recommended to set\n// a help string and to explicitly set the Objectives field to the desired value\n// as the default value will change in the upcoming v1.0.0 of the library.\ntype SummaryOpts struct {\n\t// Namespace, Subsystem, and Name are components of the fully-qualified\n\t// name of the Summary (created by joining these components with\n\t// \"_\"). Only Name is mandatory, the others merely help structuring the\n\t// name. Note that the fully-qualified name of the Summary must be a\n\t// valid Prometheus metric name.\n\tNamespace string\n\tSubsystem string\n\tName string\n\n\t// Help provides information about this Summary.\n\t//\n\t// Metrics with the same fully-qualified name must have the same Help\n\t// string.\n\tHelp string\n\n\t// ConstLabels are used to attach fixed labels to this metric. Metrics\n\t// with the same fully-qualified name must have the same label names in\n\t// their ConstLabels.\n\t//\n\t// Due to the way a Summary is represented in the Prometheus text format\n\t// and how it is handled by the Prometheus server internally, “quantile”\n\t// is an illegal label name. Construction of a Summary or SummaryVec\n\t// will panic if this label name is used in ConstLabels.\n\t//\n\t// ConstLabels are only used rarely. In particular, do not use them to\n\t// attach the same labels to all your metrics. Those use cases are\n\t// better covered by target labels set by the scraping Prometheus\n\t// server, or by one specific metric (e.g. a build_info or a\n\t// machine_role metric). See also\n\t// https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels\n\tConstLabels Labels\n\n\t// Objectives defines the quantile rank estimates with their respective\n\t// absolute error. If Objectives[q] = e, then the value reported for q\n\t// will be the φ-quantile value for some φ between q-e and q+e. The\n\t// default value is an empty map, resulting in a summary without\n\t// quantiles.\n\tObjectives map[float64]float64\n\n\t// MaxAge defines the duration for which an observation stays relevant\n\t// for the summary. Only applies to pre-calculated quantiles, does not\n\t// apply to _sum and _count. Must be positive. The default value is\n\t// DefMaxAge.\n\tMaxAge time.Duration\n\n\t// AgeBuckets is the number of buckets used to exclude observations that\n\t// are older than MaxAge from the summary. A higher number has a\n\t// resource penalty, so only increase it if the higher resolution is\n\t// really required. For very high observation rates, you might want to\n\t// reduce the number of age buckets. With only one age bucket, you will\n\t// effectively see a complete reset of the summary each time MaxAge has\n\t// passed. The default value is DefAgeBuckets.\n\tAgeBuckets uint32\n\n\t// BufCap defines the default sample stream buffer size. The default\n\t// value of DefBufCap should suffice for most uses. If there is a need\n\t// to increase the value, a multiple of 500 is recommended (because that\n\t// is the internal buffer size of the underlying package\n\t// \"github.com/bmizerany/perks/quantile\").\n\tBufCap uint32\n}\n\n// Problem with the sliding-window decay algorithm... The Merge method of\n// perk/quantile is actually not working as advertised - and it might be\n// unfixable, as the underlying algorithm is apparently not capable of merging\n// summaries in the first place. To avoid using Merge, we are currently adding\n// observations to _each_ age bucket, i.e. the effort to add a sample is\n// essentially multiplied by the number of age buckets. When rotating age\n// buckets, we empty the previous head stream. On scrape time, we simply take\n// the quantiles from the head stream (no merging required). Result: More effort\n// on observation time, less effort on scrape time, which is exactly the\n// opposite of what we try to accomplish, but at least the results are correct.\n//\n// The quite elegant previous contraption to merge the age buckets efficiently\n// on scrape time (see code up commit 6b9530d72ea715f0ba612c0120e6e09fbf1d49d0)\n// can't be used anymore.\n\n// NewSummary creates a new Summary based on the provided SummaryOpts.\nfunc NewSummary(opts SummaryOpts) Summary {\n\treturn newSummary(\n\t\tNewDesc(\n\t\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\t\topts.Help,\n\t\t\tnil,\n\t\t\topts.ConstLabels,\n\t\t),\n\t\topts,\n\t)\n}\n\nfunc newSummary(desc *Desc, opts SummaryOpts, labelValues ...string) Summary {\n\tif len(desc.variableLabels) != len(labelValues) {\n\t\tpanic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, labelValues))\n\t}\n\n\tfor _, n := range desc.variableLabels {\n\t\tif n == quantileLabel {\n\t\t\tpanic(errQuantileLabelNotAllowed)\n\t\t}\n\t}\n\tfor _, lp := range desc.constLabelPairs {\n\t\tif lp.GetName() == quantileLabel {\n\t\t\tpanic(errQuantileLabelNotAllowed)\n\t\t}\n\t}\n\n\tif opts.Objectives == nil {\n\t\topts.Objectives = map[float64]float64{}\n\t}\n\n\tif opts.MaxAge < 0 {\n\t\tpanic(fmt.Errorf(\"illegal max age MaxAge=%v\", opts.MaxAge))\n\t}\n\tif opts.MaxAge == 0 {\n\t\topts.MaxAge = DefMaxAge\n\t}\n\n\tif opts.AgeBuckets == 0 {\n\t\topts.AgeBuckets = DefAgeBuckets\n\t}\n\n\tif opts.BufCap == 0 {\n\t\topts.BufCap = DefBufCap\n\t}\n\n\tif len(opts.Objectives) == 0 {\n\t\t// Use the lock-free implementation of a Summary without objectives.\n\t\ts := &noObjectivesSummary{\n\t\t\tdesc: desc,\n\t\t\tlabelPairs: MakeLabelPairs(desc, labelValues),\n\t\t\tcounts: [2]*summaryCounts{{}, {}},\n\t\t}\n\t\ts.init(s) // Init self-collection.\n\t\treturn s\n\t}\n\n\ts := &summary{\n\t\tdesc: desc,\n\n\t\tobjectives: opts.Objectives,\n\t\tsortedObjectives: make([]float64, 0, len(opts.Objectives)),\n\n\t\tlabelPairs: MakeLabelPairs(desc, labelValues),\n\n\t\thotBuf: make([]float64, 0, opts.BufCap),\n\t\tcoldBuf: make([]float64, 0, opts.BufCap),\n\t\tstreamDuration: opts.MaxAge / time.Duration(opts.AgeBuckets),\n\t}\n\ts.headStreamExpTime = time.Now().Add(s.streamDuration)\n\ts.hotBufExpTime = s.headStreamExpTime\n\n\tfor i := uint32(0); i < opts.AgeBuckets; i++ {\n\t\ts.streams = append(s.streams, s.newStream())\n\t}\n\ts.headStream = s.streams[0]\n\n\tfor qu := range s.objectives {\n\t\ts.sortedObjectives = append(s.sortedObjectives, qu)\n\t}\n\tsort.Float64s(s.sortedObjectives)\n\n\ts.init(s) // Init self-collection.\n\treturn s\n}\n\ntype summary struct {\n\tselfCollector\n\n\tbufMtx sync.Mutex // Protects hotBuf and hotBufExpTime.\n\tmtx sync.Mutex // Protects every other moving part.\n\t// Lock bufMtx before mtx if both are needed.\n\n\tdesc *Desc\n\n\tobjectives map[float64]float64\n\tsortedObjectives []float64\n\n\tlabelPairs []*dto.LabelPair\n\n\tsum float64\n\tcnt uint64\n\n\thotBuf, coldBuf []float64\n\n\tstreams []*quantile.Stream\n\tstreamDuration time.Duration\n\theadStream *quantile.Stream\n\theadStreamIdx int\n\theadStreamExpTime, hotBufExpTime time.Time\n}\n\nfunc (s *summary) Desc() *Desc {\n\treturn s.desc\n}\n\nfunc (s *summary) Observe(v float64) {\n\ts.bufMtx.Lock()\n\tdefer s.bufMtx.Unlock()\n\n\tnow := time.Now()\n\tif now.After(s.hotBufExpTime) {\n\t\ts.asyncFlush(now)\n\t}\n\ts.hotBuf = append(s.hotBuf, v)\n\tif len(s.hotBuf) == cap(s.hotBuf) {\n\t\ts.asyncFlush(now)\n\t}\n}\n\nfunc (s *summary) Write(out *dto.Metric) error {\n\tsum := &dto.Summary{}\n\tqs := make([]*dto.Quantile, 0, len(s.objectives))\n\n\ts.bufMtx.Lock()\n\ts.mtx.Lock()\n\t// Swap bufs even if hotBuf is empty to set new hotBufExpTime.\n\ts.swapBufs(time.Now())\n\ts.bufMtx.Unlock()\n\n\ts.flushColdBuf()\n\tsum.SampleCount = proto.Uint64(s.cnt)\n\tsum.SampleSum = proto.Float64(s.sum)\n\n\tfor _, rank := range s.sortedObjectives {\n\t\tvar q float64\n\t\tif s.headStream.Count() == 0 {\n\t\t\tq = math.NaN()\n\t\t} else {\n\t\t\tq = s.headStream.Query(rank)\n\t\t}\n\t\tqs = append(qs, &dto.Quantile{\n\t\t\tQuantile: proto.Float64(rank),\n\t\t\tValue: proto.Float64(q),\n\t\t})\n\t}\n\n\ts.mtx.Unlock()\n\n\tif len(qs) > 0 {\n\t\tsort.Sort(quantSort(qs))\n\t}\n\tsum.Quantile = qs\n\n\tout.Summary = sum\n\tout.Label = s.labelPairs\n\treturn nil\n}\n\nfunc (s *summary) newStream() *quantile.Stream {\n\treturn quantile.NewTargeted(s.objectives)\n}\n\n// asyncFlush needs bufMtx locked.\nfunc (s *summary) asyncFlush(now time.Time) {\n\ts.mtx.Lock()\n\ts.swapBufs(now)\n\n\t// Unblock the original goroutine that was responsible for the mutation\n\t// that triggered the compaction. But hold onto the global non-buffer\n\t// state mutex until the operation finishes.\n\tgo func() {\n\t\ts.flushColdBuf()\n\t\ts.mtx.Unlock()\n\t}()\n}\n\n// rotateStreams needs mtx AND bufMtx locked.\nfunc (s *summary) maybeRotateStreams() {\n\tfor !s.hotBufExpTime.Equal(s.headStreamExpTime) {\n\t\ts.headStream.Reset()\n\t\ts.headStreamIdx++\n\t\tif s.headStreamIdx >= len(s.streams) {\n\t\t\ts.headStreamIdx = 0\n\t\t}\n\t\ts.headStream = s.streams[s.headStreamIdx]\n\t\ts.headStreamExpTime = s.headStreamExpTime.Add(s.streamDuration)\n\t}\n}\n\n// flushColdBuf needs mtx locked.\nfunc (s *summary) flushColdBuf() {\n\tfor _, v := range s.coldBuf {\n\t\tfor _, stream := range s.streams {\n\t\t\tstream.Insert(v)\n\t\t}\n\t\ts.cnt++\n\t\ts.sum += v\n\t}\n\ts.coldBuf = s.coldBuf[0:0]\n\ts.maybeRotateStreams()\n}\n\n// swapBufs needs mtx AND bufMtx locked, coldBuf must be empty.\nfunc (s *summary) swapBufs(now time.Time) {\n\tif len(s.coldBuf) != 0 {\n\t\tpanic(\"coldBuf is not empty\")\n\t}\n\ts.hotBuf, s.coldBuf = s.coldBuf, s.hotBuf\n\t// hotBuf is now empty and gets new expiration set.\n\tfor now.After(s.hotBufExpTime) {\n\t\ts.hotBufExpTime = s.hotBufExpTime.Add(s.streamDuration)\n\t}\n}\n\ntype summaryCounts struct {\n\t// sumBits contains the bits of the float64 representing the sum of all\n\t// observations. sumBits and count have to go first in the struct to\n\t// guarantee alignment for atomic operations.\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\tsumBits uint64\n\tcount uint64\n}\n\ntype noObjectivesSummary struct {\n\t// countAndHotIdx enables lock-free writes with use of atomic updates.\n\t// The most significant bit is the hot index [0 or 1] of the count field\n\t// below. Observe calls update the hot one. All remaining bits count the\n\t// number of Observe calls. Observe starts by incrementing this counter,\n\t// and finish by incrementing the count field in the respective\n\t// summaryCounts, as a marker for completion.\n\t//\n\t// Calls of the Write method (which are non-mutating reads from the\n\t// perspective of the summary) swap the hot–cold under the writeMtx\n\t// lock. A cooldown is awaited (while locked) by comparing the number of\n\t// observations with the initiation count. Once they match, then the\n\t// last observation on the now cool one has completed. All cool fields must\n\t// be merged into the new hot before releasing writeMtx.\n\n\t// Fields with atomic access first! See alignment constraint:\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG\n\tcountAndHotIdx uint64\n\n\tselfCollector\n\tdesc *Desc\n\twriteMtx sync.Mutex // Only used in the Write method.\n\n\t// Two counts, one is \"hot\" for lock-free observations, the other is\n\t// \"cold\" for writing out a dto.Metric. It has to be an array of\n\t// pointers to guarantee 64bit alignment of the histogramCounts, see\n\t// http://golang.org/pkg/sync/atomic/#pkg-note-BUG.\n\tcounts [2]*summaryCounts\n\n\tlabelPairs []*dto.LabelPair\n}\n\nfunc (s *noObjectivesSummary) Desc() *Desc {\n\treturn s.desc\n}\n\nfunc (s *noObjectivesSummary) Observe(v float64) {\n\t// We increment h.countAndHotIdx so that the counter in the lower\n\t// 63 bits gets incremented. At the same time, we get the new value\n\t// back, which we can use to find the currently-hot counts.\n\tn := atomic.AddUint64(&s.countAndHotIdx, 1)\n\thotCounts := s.counts[n>>63]\n\n\tfor {\n\t\toldBits := atomic.LoadUint64(&hotCounts.sumBits)\n\t\tnewBits := math.Float64bits(math.Float64frombits(oldBits) + v)\n\t\tif atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {\n\t\t\tbreak\n\t\t}\n\t}\n\t// Increment count last as we take it as a signal that the observation\n\t// is complete.\n\tatomic.AddUint64(&hotCounts.count, 1)\n}\n\nfunc (s *noObjectivesSummary) Write(out *dto.Metric) error {\n\t// For simplicity, we protect this whole method by a mutex. It is not in\n\t// the hot path, i.e. Observe is called much more often than Write. The\n\t// complication of making Write lock-free isn't worth it, if possible at\n\t// all.\n\ts.writeMtx.Lock()\n\tdefer s.writeMtx.Unlock()\n\n\t// Adding 1<<63 switches the hot index (from 0 to 1 or from 1 to 0)\n\t// without touching the count bits. See the struct comments for a full\n\t// description of the algorithm.\n\tn := atomic.AddUint64(&s.countAndHotIdx, 1<<63)\n\t// count is contained unchanged in the lower 63 bits.\n\tcount := n & ((1 << 63) - 1)\n\t// The most significant bit tells us which counts is hot. The complement\n\t// is thus the cold one.\n\thotCounts := s.counts[n>>63]\n\tcoldCounts := s.counts[(^n)>>63]\n\n\t// Await cooldown.\n\tfor count != atomic.LoadUint64(&coldCounts.count) {\n\t\truntime.Gosched() // Let observations get work done.\n\t}\n\n\tsum := &dto.Summary{\n\t\tSampleCount: proto.Uint64(count),\n\t\tSampleSum: proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),\n\t}\n\n\tout.Summary = sum\n\tout.Label = s.labelPairs\n\n\t// Finally add all the cold counts to the new hot counts and reset the cold counts.\n\tatomic.AddUint64(&hotCounts.count, count)\n\tatomic.StoreUint64(&coldCounts.count, 0)\n\tfor {\n\t\toldBits := atomic.LoadUint64(&hotCounts.sumBits)\n\t\tnewBits := math.Float64bits(math.Float64frombits(oldBits) + sum.GetSampleSum())\n\t\tif atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {\n\t\t\tatomic.StoreUint64(&coldCounts.sumBits, 0)\n\t\t\tbreak\n\t\t}\n\t}\n\treturn nil\n}\n\ntype quantSort []*dto.Quantile\n\nfunc (s quantSort) Len() int {\n\treturn len(s)\n}\n\nfunc (s quantSort) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc (s quantSort) Less(i, j int) bool {\n\treturn s[i].GetQuantile() < s[j].GetQuantile()\n}\n\n// SummaryVec is a Collector that bundles a set of Summaries that all share the\n// same Desc, but have different values for their variable labels. This is used\n// if you want to count the same thing partitioned by various dimensions\n// (e.g. HTTP request latencies, partitioned by status code and method). Create\n// instances with NewSummaryVec.\ntype SummaryVec struct {\n\t*MetricVec\n}\n\n// NewSummaryVec creates a new SummaryVec based on the provided SummaryOpts and\n// partitioned by the given label names.\n//\n// Due to the way a Summary is represented in the Prometheus text format and how\n// it is handled by the Prometheus server internally, “quantile” is an illegal\n// label name. NewSummaryVec will panic if this label name is used.\nfunc NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec {\n\tfor _, ln := range labelNames {\n\t\tif ln == quantileLabel {\n\t\t\tpanic(errQuantileLabelNotAllowed)\n\t\t}\n\t}\n\tdesc := NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tlabelNames,\n\t\topts.ConstLabels,\n\t)\n\treturn &SummaryVec{\n\t\tMetricVec: NewMetricVec(desc, func(lvs ...string) Metric {\n\t\t\treturn newSummary(desc, opts, lvs...)\n\t\t}),\n\t}\n}\n\n// GetMetricWithLabelValues returns the Summary for the given slice of label\n// values (same order as the variable labels in Desc). If that combination of\n// label values is accessed for the first time, a new Summary is created.\n//\n// It is possible to call this method without using the returned Summary to only\n// create the new Summary but leave it at its starting value, a Summary without\n// any observations.\n//\n// Keeping the Summary for later use is possible (and should be considered if\n// performance is critical), but keep in mind that Reset, DeleteLabelValues and\n// Delete can be used to delete the Summary from the SummaryVec. In that case,\n// the Summary will still exist, but it will not be exported anymore, even if a\n// Summary with the same label values is created later. See also the CounterVec\n// example.\n//\n// An error is returned if the number of label values is not the same as the\n// number of variable labels in Desc (minus any curried labels).\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as\n// an alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\n// See also the GaugeVec example.\nfunc (v *SummaryVec) GetMetricWithLabelValues(lvs ...string) (Observer, error) {\n\tmetric, err := v.MetricVec.GetMetricWithLabelValues(lvs...)\n\tif metric != nil {\n\t\treturn metric.(Observer), err\n\t}\n\treturn nil, err\n}\n\n// GetMetricWith returns the Summary for the given Labels map (the label names\n// must match those of the variable labels in Desc). If that label map is\n// accessed for the first time, a new Summary is created. Implications of\n// creating a Summary without using it and keeping the Summary for later use are\n// the same as for GetMetricWithLabelValues.\n//\n// An error is returned if the number and names of the Labels are inconsistent\n// with those of the variable labels in Desc (minus any curried labels).\n//\n// This method is used for the same purpose as\n// GetMetricWithLabelValues(...string). See there for pros and cons of the two\n// methods.\nfunc (v *SummaryVec) GetMetricWith(labels Labels) (Observer, error) {\n\tmetric, err := v.MetricVec.GetMetricWith(labels)\n\tif metric != nil {\n\t\treturn metric.(Observer), err\n\t}\n\treturn nil, err\n}\n\n// WithLabelValues works as GetMetricWithLabelValues, but panics where\n// GetMetricWithLabelValues would have returned an error. Not returning an\n// error allows shortcuts like\n//\n//\tmyVec.WithLabelValues(\"404\", \"GET\").Observe(42.21)\nfunc (v *SummaryVec) WithLabelValues(lvs ...string) Observer {\n\ts, err := v.GetMetricWithLabelValues(lvs...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn s\n}\n\n// With works as GetMetricWith, but panics where GetMetricWithLabels would have\n// returned an error. Not returning an error allows shortcuts like\n//\n//\tmyVec.With(prometheus.Labels{\"code\": \"404\", \"method\": \"GET\"}).Observe(42.21)\nfunc (v *SummaryVec) With(labels Labels) Observer {\n\ts, err := v.GetMetricWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn s\n}\n\n// CurryWith returns a vector curried with the provided labels, i.e. the\n// returned vector has those labels pre-set for all labeled operations performed\n// on it. The cardinality of the curried vector is reduced accordingly. The\n// order of the remaining labels stays the same (just with the curried labels\n// taken out of the sequence – which is relevant for the\n// (GetMetric)WithLabelValues methods). It is possible to curry a curried\n// vector, but only with labels not yet used for currying before.\n//\n// The metrics contained in the SummaryVec are shared between the curried and\n// uncurried vectors. They are just accessed differently. Curried and uncurried\n// vectors behave identically in terms of collection. Only one must be\n// registered with a given registry (usually the uncurried version). The Reset\n// method deletes all metrics, even if called on a curried vector.\nfunc (v *SummaryVec) CurryWith(labels Labels) (ObserverVec, error) {\n\tvec, err := v.MetricVec.CurryWith(labels)\n\tif vec != nil {\n\t\treturn &SummaryVec{vec}, err\n\t}\n\treturn nil, err\n}\n\n// MustCurryWith works as CurryWith but panics where CurryWith would have\n// returned an error.\nfunc (v *SummaryVec) MustCurryWith(labels Labels) ObserverVec {\n\tvec, err := v.CurryWith(labels)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn vec\n}\n\ntype constSummary struct {\n\tdesc *Desc\n\tcount uint64\n\tsum float64\n\tquantiles map[float64]float64\n\tlabelPairs []*dto.LabelPair\n}\n\nfunc (s *constSummary) Desc() *Desc {\n\treturn s.desc\n}\n\nfunc (s *constSummary) Write(out *dto.Metric) error {\n\tsum := &dto.Summary{}\n\tqs := make([]*dto.Quantile, 0, len(s.quantiles))\n\n\tsum.SampleCount = proto.Uint64(s.count)\n\tsum.SampleSum = proto.Float64(s.sum)\n\n\tfor rank, q := range s.quantiles {\n\t\tqs = append(qs, &dto.Quantile{\n\t\t\tQuantile: proto.Float64(rank),\n\t\t\tValue: proto.Float64(q),\n\t\t})\n\t}\n\n\tif len(qs) > 0 {\n\t\tsort.Sort(quantSort(qs))\n\t}\n\tsum.Quantile = qs\n\n\tout.Summary = sum\n\tout.Label = s.labelPairs\n\n\treturn nil\n}\n\n// NewConstSummary returns a metric representing a Prometheus summary with fixed\n// values for the count, sum, and quantiles. As those parameters cannot be\n// changed, the returned value does not implement the Summary interface (but\n// only the Metric interface). Users of this package will not have much use for\n// it in regular operations. However, when implementing custom Collectors, it is\n// useful as a throw-away metric that is generated on the fly to send it to\n// Prometheus in the Collect method.\n//\n// quantiles maps ranks to quantile values. For example, a median latency of\n// 0.23s and a 99th percentile latency of 0.56s would be expressed as:\n//\n//\tmap[float64]float64{0.5: 0.23, 0.99: 0.56}\n//\n// NewConstSummary returns an error if the length of labelValues is not\n// consistent with the variable labels in Desc or if Desc is invalid.\nfunc NewConstSummary(\n\tdesc *Desc,\n\tcount uint64,\n\tsum float64,\n\tquantiles map[float64]float64,\n\tlabelValues ...string,\n) (Metric, error) {\n\tif desc.err != nil {\n\t\treturn nil, desc.err\n\t}\n\tif err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {\n\t\treturn nil, err\n\t}\n\treturn &constSummary{\n\t\tdesc: desc,\n\t\tcount: count,\n\t\tsum: sum,\n\t\tquantiles: quantiles,\n\t\tlabelPairs: MakeLabelPairs(desc, labelValues),\n\t}, nil\n}\n\n// MustNewConstSummary is a version of NewConstSummary that panics where\n// NewConstMetric would have returned an error.\nfunc MustNewConstSummary(\n\tdesc *Desc,\n\tcount uint64,\n\tsum float64,\n\tquantiles map[float64]float64,\n\tlabelValues ...string,\n) Metric {\n\tm, err := NewConstSummary(desc, count, sum, quantiles, labelValues...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn m\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/timer.go",
"content": "// Copyright 2016 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport \"time\"\n\n// Timer is a helper type to time functions. Use NewTimer to create new\n// instances.\ntype Timer struct {\n\tbegin time.Time\n\tobserver Observer\n}\n\n// NewTimer creates a new Timer. The provided Observer is used to observe a\n// duration in seconds. Timer is usually used to time a function call in the\n// following way:\n//\n//\tfunc TimeMe() {\n//\t timer := NewTimer(myHistogram)\n//\t defer timer.ObserveDuration()\n//\t // Do actual work.\n//\t}\nfunc NewTimer(o Observer) *Timer {\n\treturn &Timer{\n\t\tbegin: time.Now(),\n\t\tobserver: o,\n\t}\n}\n\n// ObserveDuration records the duration passed since the Timer was created with\n// NewTimer. It calls the Observe method of the Observer provided during\n// construction with the duration in seconds as an argument. The observed\n// duration is also returned. ObserveDuration is usually called with a defer\n// statement.\n//\n// Note that this method is only guaranteed to never observe negative durations\n// if used with Go1.9+.\nfunc (t *Timer) ObserveDuration() time.Duration {\n\td := time.Since(t.begin)\n\tif t.observer != nil {\n\t\tt.observer.Observe(d.Seconds())\n\t}\n\treturn d\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/untyped.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\n// UntypedOpts is an alias for Opts. See there for doc comments.\ntype UntypedOpts Opts\n\n// UntypedFunc works like GaugeFunc but the collected metric is of type\n// \"Untyped\". UntypedFunc is useful to mirror an external metric of unknown\n// type.\n//\n// To create UntypedFunc instances, use NewUntypedFunc.\ntype UntypedFunc interface {\n\tMetric\n\tCollector\n}\n\n// NewUntypedFunc creates a new UntypedFunc based on the provided\n// UntypedOpts. The value reported is determined by calling the given function\n// from within the Write method. Take into account that metric collection may\n// happen concurrently. If that results in concurrent calls to Write, like in\n// the case where an UntypedFunc is directly registered with Prometheus, the\n// provided function must be concurrency-safe.\nfunc NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc {\n\treturn newValueFunc(NewDesc(\n\t\tBuildFQName(opts.Namespace, opts.Subsystem, opts.Name),\n\t\topts.Help,\n\t\tnil,\n\t\topts.ConstLabels,\n\t), UntypedValue, function)\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/value.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"fmt\"\n\t\"sort\"\n\t\"time\"\n\t\"unicode/utf8\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\t\"google.golang.org/protobuf/types/known/timestamppb\"\n\n\t\"github.com/prometheus/client_golang/prometheus/internal\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// ValueType is an enumeration of metric types that represent a simple value.\ntype ValueType int\n\n// Possible values for the ValueType enum. Use UntypedValue to mark a metric\n// with an unknown type.\nconst (\n\t_ ValueType = iota\n\tCounterValue\n\tGaugeValue\n\tUntypedValue\n)\n\nvar (\n\tCounterMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_COUNTER; return &d }()\n\tGaugeMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_GAUGE; return &d }()\n\tUntypedMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_UNTYPED; return &d }()\n)\n\nfunc (v ValueType) ToDTO() *dto.MetricType {\n\tswitch v {\n\tcase CounterValue:\n\t\treturn CounterMetricTypePtr\n\tcase GaugeValue:\n\t\treturn GaugeMetricTypePtr\n\tdefault:\n\t\treturn UntypedMetricTypePtr\n\t}\n}\n\n// valueFunc is a generic metric for simple values retrieved on collect time\n// from a function. It implements Metric and Collector. Its effective type is\n// determined by ValueType. This is a low-level building block used by the\n// library to back the implementations of CounterFunc, GaugeFunc, and\n// UntypedFunc.\ntype valueFunc struct {\n\tselfCollector\n\n\tdesc *Desc\n\tvalType ValueType\n\tfunction func() float64\n\tlabelPairs []*dto.LabelPair\n}\n\n// newValueFunc returns a newly allocated valueFunc with the given Desc and\n// ValueType. The value reported is determined by calling the given function\n// from within the Write method. Take into account that metric collection may\n// happen concurrently. If that results in concurrent calls to Write, like in\n// the case where a valueFunc is directly registered with Prometheus, the\n// provided function must be concurrency-safe.\nfunc newValueFunc(desc *Desc, valueType ValueType, function func() float64) *valueFunc {\n\tresult := &valueFunc{\n\t\tdesc: desc,\n\t\tvalType: valueType,\n\t\tfunction: function,\n\t\tlabelPairs: MakeLabelPairs(desc, nil),\n\t}\n\tresult.init(result)\n\treturn result\n}\n\nfunc (v *valueFunc) Desc() *Desc {\n\treturn v.desc\n}\n\nfunc (v *valueFunc) Write(out *dto.Metric) error {\n\treturn populateMetric(v.valType, v.function(), v.labelPairs, nil, out)\n}\n\n// NewConstMetric returns a metric with one fixed value that cannot be\n// changed. Users of this package will not have much use for it in regular\n// operations. However, when implementing custom Collectors, it is useful as a\n// throw-away metric that is generated on the fly to send it to Prometheus in\n// the Collect method. NewConstMetric returns an error if the length of\n// labelValues is not consistent with the variable labels in Desc or if Desc is\n// invalid.\nfunc NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error) {\n\tif desc.err != nil {\n\t\treturn nil, desc.err\n\t}\n\tif err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {\n\t\treturn nil, err\n\t}\n\n\tmetric := &dto.Metric{}\n\tif err := populateMetric(valueType, value, MakeLabelPairs(desc, labelValues), nil, metric); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn &constMetric{\n\t\tdesc: desc,\n\t\tmetric: metric,\n\t}, nil\n}\n\n// MustNewConstMetric is a version of NewConstMetric that panics where\n// NewConstMetric would have returned an error.\nfunc MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric {\n\tm, err := NewConstMetric(desc, valueType, value, labelValues...)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn m\n}\n\ntype constMetric struct {\n\tdesc *Desc\n\tmetric *dto.Metric\n}\n\nfunc (m *constMetric) Desc() *Desc {\n\treturn m.desc\n}\n\nfunc (m *constMetric) Write(out *dto.Metric) error {\n\tout.Label = m.metric.Label\n\tout.Counter = m.metric.Counter\n\tout.Gauge = m.metric.Gauge\n\tout.Untyped = m.metric.Untyped\n\treturn nil\n}\n\nfunc populateMetric(\n\tt ValueType,\n\tv float64,\n\tlabelPairs []*dto.LabelPair,\n\te *dto.Exemplar,\n\tm *dto.Metric,\n) error {\n\tm.Label = labelPairs\n\tswitch t {\n\tcase CounterValue:\n\t\tm.Counter = &dto.Counter{Value: proto.Float64(v), Exemplar: e}\n\tcase GaugeValue:\n\t\tm.Gauge = &dto.Gauge{Value: proto.Float64(v)}\n\tcase UntypedValue:\n\t\tm.Untyped = &dto.Untyped{Value: proto.Float64(v)}\n\tdefault:\n\t\treturn fmt.Errorf(\"encountered unknown type %v\", t)\n\t}\n\treturn nil\n}\n\n// MakeLabelPairs is a helper function to create protobuf LabelPairs from the\n// variable and constant labels in the provided Desc. The values for the\n// variable labels are defined by the labelValues slice, which must be in the\n// same order as the corresponding variable labels in the Desc.\n//\n// This function is only needed for custom Metric implementations. See MetricVec\n// example.\nfunc MakeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair {\n\ttotalLen := len(desc.variableLabels) + len(desc.constLabelPairs)\n\tif totalLen == 0 {\n\t\t// Super fast path.\n\t\treturn nil\n\t}\n\tif len(desc.variableLabels) == 0 {\n\t\t// Moderately fast path.\n\t\treturn desc.constLabelPairs\n\t}\n\tlabelPairs := make([]*dto.LabelPair, 0, totalLen)\n\tfor i, n := range desc.variableLabels {\n\t\tlabelPairs = append(labelPairs, &dto.LabelPair{\n\t\t\tName: proto.String(n),\n\t\t\tValue: proto.String(labelValues[i]),\n\t\t})\n\t}\n\tlabelPairs = append(labelPairs, desc.constLabelPairs...)\n\tsort.Sort(internal.LabelPairSorter(labelPairs))\n\treturn labelPairs\n}\n\n// ExemplarMaxRunes is the max total number of runes allowed in exemplar labels.\nconst ExemplarMaxRunes = 128\n\n// newExemplar creates a new dto.Exemplar from the provided values. An error is\n// returned if any of the label names or values are invalid or if the total\n// number of runes in the label names and values exceeds ExemplarMaxRunes.\nfunc newExemplar(value float64, ts time.Time, l Labels) (*dto.Exemplar, error) {\n\te := &dto.Exemplar{}\n\te.Value = proto.Float64(value)\n\ttsProto := timestamppb.New(ts)\n\tif err := tsProto.CheckValid(); err != nil {\n\t\treturn nil, err\n\t}\n\te.Timestamp = tsProto\n\tlabelPairs := make([]*dto.LabelPair, 0, len(l))\n\tvar runes int\n\tfor name, value := range l {\n\t\tif !checkLabelName(name) {\n\t\t\treturn nil, fmt.Errorf(\"exemplar label name %q is invalid\", name)\n\t\t}\n\t\trunes += utf8.RuneCountInString(name)\n\t\tif !utf8.ValidString(value) {\n\t\t\treturn nil, fmt.Errorf(\"exemplar label value %q is not valid UTF-8\", value)\n\t\t}\n\t\trunes += utf8.RuneCountInString(value)\n\t\tlabelPairs = append(labelPairs, &dto.LabelPair{\n\t\t\tName: proto.String(name),\n\t\t\tValue: proto.String(value),\n\t\t})\n\t}\n\tif runes > ExemplarMaxRunes {\n\t\treturn nil, fmt.Errorf(\"exemplar labels have %d runes, exceeding the limit of %d\", runes, ExemplarMaxRunes)\n\t}\n\te.Label = labelPairs\n\treturn e, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/vec.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"fmt\"\n\t\"sync\"\n\n\t\"github.com/prometheus/common/model\"\n)\n\n// MetricVec is a Collector to bundle metrics of the same name that differ in\n// their label values. MetricVec is not used directly but as a building block\n// for implementations of vectors of a given metric type, like GaugeVec,\n// CounterVec, SummaryVec, and HistogramVec. It is exported so that it can be\n// used for custom Metric implementations.\n//\n// To create a FooVec for custom Metric Foo, embed a pointer to MetricVec in\n// FooVec and initialize it with NewMetricVec. Implement wrappers for\n// GetMetricWithLabelValues and GetMetricWith that return (Foo, error) rather\n// than (Metric, error). Similarly, create a wrapper for CurryWith that returns\n// (*FooVec, error) rather than (*MetricVec, error). It is recommended to also\n// add the convenience methods WithLabelValues, With, and MustCurryWith, which\n// panic instead of returning errors. See also the MetricVec example.\ntype MetricVec struct {\n\t*metricMap\n\n\tcurry []curriedLabelValue\n\n\t// hashAdd and hashAddByte can be replaced for testing collision handling.\n\thashAdd func(h uint64, s string) uint64\n\thashAddByte func(h uint64, b byte) uint64\n}\n\n// NewMetricVec returns an initialized metricVec.\nfunc NewMetricVec(desc *Desc, newMetric func(lvs ...string) Metric) *MetricVec {\n\treturn &MetricVec{\n\t\tmetricMap: &metricMap{\n\t\t\tmetrics: map[uint64][]metricWithLabelValues{},\n\t\t\tdesc: desc,\n\t\t\tnewMetric: newMetric,\n\t\t},\n\t\thashAdd: hashAdd,\n\t\thashAddByte: hashAddByte,\n\t}\n}\n\n// DeleteLabelValues removes the metric where the variable labels are the same\n// as those passed in as labels (same order as the VariableLabels in Desc). It\n// returns true if a metric was deleted.\n//\n// It is not an error if the number of label values is not the same as the\n// number of VariableLabels in Desc. However, such inconsistent label count can\n// never match an actual metric, so the method will always return false in that\n// case.\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider Delete(Labels) as an\n// alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\n// See also the CounterVec example.\nfunc (m *MetricVec) DeleteLabelValues(lvs ...string) bool {\n\th, err := m.hashLabelValues(lvs)\n\tif err != nil {\n\t\treturn false\n\t}\n\n\treturn m.metricMap.deleteByHashWithLabelValues(h, lvs, m.curry)\n}\n\n// Delete deletes the metric where the variable labels are the same as those\n// passed in as labels. It returns true if a metric was deleted.\n//\n// It is not an error if the number and names of the Labels are inconsistent\n// with those of the VariableLabels in Desc. However, such inconsistent Labels\n// can never match an actual metric, so the method will always return false in\n// that case.\n//\n// This method is used for the same purpose as DeleteLabelValues(...string). See\n// there for pros and cons of the two methods.\nfunc (m *MetricVec) Delete(labels Labels) bool {\n\th, err := m.hashLabels(labels)\n\tif err != nil {\n\t\treturn false\n\t}\n\n\treturn m.metricMap.deleteByHashWithLabels(h, labels, m.curry)\n}\n\n// DeletePartialMatch deletes all metrics where the variable labels contain all of those\n// passed in as labels. The order of the labels does not matter.\n// It returns the number of metrics deleted.\n//\n// Note that curried labels will never be matched if deleting from the curried vector.\n// To match curried labels with DeletePartialMatch, it must be called on the base vector.\nfunc (m *MetricVec) DeletePartialMatch(labels Labels) int {\n\treturn m.metricMap.deleteByLabels(labels, m.curry)\n}\n\n// Without explicit forwarding of Describe, Collect, Reset, those methods won't\n// show up in GoDoc.\n\n// Describe implements Collector.\nfunc (m *MetricVec) Describe(ch chan<- *Desc) { m.metricMap.Describe(ch) }\n\n// Collect implements Collector.\nfunc (m *MetricVec) Collect(ch chan<- Metric) { m.metricMap.Collect(ch) }\n\n// Reset deletes all metrics in this vector.\nfunc (m *MetricVec) Reset() { m.metricMap.Reset() }\n\n// CurryWith returns a vector curried with the provided labels, i.e. the\n// returned vector has those labels pre-set for all labeled operations performed\n// on it. The cardinality of the curried vector is reduced accordingly. The\n// order of the remaining labels stays the same (just with the curried labels\n// taken out of the sequence – which is relevant for the\n// (GetMetric)WithLabelValues methods). It is possible to curry a curried\n// vector, but only with labels not yet used for currying before.\n//\n// The metrics contained in the MetricVec are shared between the curried and\n// uncurried vectors. They are just accessed differently. Curried and uncurried\n// vectors behave identically in terms of collection. Only one must be\n// registered with a given registry (usually the uncurried version). The Reset\n// method deletes all metrics, even if called on a curried vector.\n//\n// Note that CurryWith is usually not called directly but through a wrapper\n// around MetricVec, implementing a vector for a specific Metric\n// implementation, for example GaugeVec.\nfunc (m *MetricVec) CurryWith(labels Labels) (*MetricVec, error) {\n\tvar (\n\t\tnewCurry []curriedLabelValue\n\t\toldCurry = m.curry\n\t\tiCurry int\n\t)\n\tfor i, label := range m.desc.variableLabels {\n\t\tval, ok := labels[label]\n\t\tif iCurry < len(oldCurry) && oldCurry[iCurry].index == i {\n\t\t\tif ok {\n\t\t\t\treturn nil, fmt.Errorf(\"label name %q is already curried\", label)\n\t\t\t}\n\t\t\tnewCurry = append(newCurry, oldCurry[iCurry])\n\t\t\tiCurry++\n\t\t} else {\n\t\t\tif !ok {\n\t\t\t\tcontinue // Label stays uncurried.\n\t\t\t}\n\t\t\tnewCurry = append(newCurry, curriedLabelValue{i, val})\n\t\t}\n\t}\n\tif l := len(oldCurry) + len(labels) - len(newCurry); l > 0 {\n\t\treturn nil, fmt.Errorf(\"%d unknown label(s) found during currying\", l)\n\t}\n\n\treturn &MetricVec{\n\t\tmetricMap: m.metricMap,\n\t\tcurry: newCurry,\n\t\thashAdd: m.hashAdd,\n\t\thashAddByte: m.hashAddByte,\n\t}, nil\n}\n\n// GetMetricWithLabelValues returns the Metric for the given slice of label\n// values (same order as the variable labels in Desc). If that combination of\n// label values is accessed for the first time, a new Metric is created (by\n// calling the newMetric function provided during construction of the\n// MetricVec).\n//\n// It is possible to call this method without using the returned Metric to only\n// create the new Metric but leave it in its initial state.\n//\n// Keeping the Metric for later use is possible (and should be considered if\n// performance is critical), but keep in mind that Reset, DeleteLabelValues and\n// Delete can be used to delete the Metric from the MetricVec. In that case, the\n// Metric will still exist, but it will not be exported anymore, even if a\n// Metric with the same label values is created later.\n//\n// An error is returned if the number of label values is not the same as the\n// number of variable labels in Desc (minus any curried labels).\n//\n// Note that for more than one label value, this method is prone to mistakes\n// caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as\n// an alternative to avoid that type of mistake. For higher label numbers, the\n// latter has a much more readable (albeit more verbose) syntax, but it comes\n// with a performance overhead (for creating and processing the Labels map).\n//\n// Note that GetMetricWithLabelValues is usually not called directly but through\n// a wrapper around MetricVec, implementing a vector for a specific Metric\n// implementation, for example GaugeVec.\nfunc (m *MetricVec) GetMetricWithLabelValues(lvs ...string) (Metric, error) {\n\th, err := m.hashLabelValues(lvs)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn m.metricMap.getOrCreateMetricWithLabelValues(h, lvs, m.curry), nil\n}\n\n// GetMetricWith returns the Metric for the given Labels map (the label names\n// must match those of the variable labels in Desc). If that label map is\n// accessed for the first time, a new Metric is created. Implications of\n// creating a Metric without using it and keeping the Metric for later use\n// are the same as for GetMetricWithLabelValues.\n//\n// An error is returned if the number and names of the Labels are inconsistent\n// with those of the variable labels in Desc (minus any curried labels).\n//\n// This method is used for the same purpose as\n// GetMetricWithLabelValues(...string). See there for pros and cons of the two\n// methods.\n//\n// Note that GetMetricWith is usually not called directly but through a wrapper\n// around MetricVec, implementing a vector for a specific Metric implementation,\n// for example GaugeVec.\nfunc (m *MetricVec) GetMetricWith(labels Labels) (Metric, error) {\n\th, err := m.hashLabels(labels)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn m.metricMap.getOrCreateMetricWithLabels(h, labels, m.curry), nil\n}\n\nfunc (m *MetricVec) hashLabelValues(vals []string) (uint64, error) {\n\tif err := validateLabelValues(vals, len(m.desc.variableLabels)-len(m.curry)); err != nil {\n\t\treturn 0, err\n\t}\n\n\tvar (\n\t\th = hashNew()\n\t\tcurry = m.curry\n\t\tiVals, iCurry int\n\t)\n\tfor i := 0; i < len(m.desc.variableLabels); i++ {\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\th = m.hashAdd(h, curry[iCurry].value)\n\t\t\tiCurry++\n\t\t} else {\n\t\t\th = m.hashAdd(h, vals[iVals])\n\t\t\tiVals++\n\t\t}\n\t\th = m.hashAddByte(h, model.SeparatorByte)\n\t}\n\treturn h, nil\n}\n\nfunc (m *MetricVec) hashLabels(labels Labels) (uint64, error) {\n\tif err := validateValuesInLabels(labels, len(m.desc.variableLabels)-len(m.curry)); err != nil {\n\t\treturn 0, err\n\t}\n\n\tvar (\n\t\th = hashNew()\n\t\tcurry = m.curry\n\t\tiCurry int\n\t)\n\tfor i, label := range m.desc.variableLabels {\n\t\tval, ok := labels[label]\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\tif ok {\n\t\t\t\treturn 0, fmt.Errorf(\"label name %q is already curried\", label)\n\t\t\t}\n\t\t\th = m.hashAdd(h, curry[iCurry].value)\n\t\t\tiCurry++\n\t\t} else {\n\t\t\tif !ok {\n\t\t\t\treturn 0, fmt.Errorf(\"label name %q missing in label map\", label)\n\t\t\t}\n\t\t\th = m.hashAdd(h, val)\n\t\t}\n\t\th = m.hashAddByte(h, model.SeparatorByte)\n\t}\n\treturn h, nil\n}\n\n// metricWithLabelValues provides the metric and its label values for\n// disambiguation on hash collision.\ntype metricWithLabelValues struct {\n\tvalues []string\n\tmetric Metric\n}\n\n// curriedLabelValue sets the curried value for a label at the given index.\ntype curriedLabelValue struct {\n\tindex int\n\tvalue string\n}\n\n// metricMap is a helper for metricVec and shared between differently curried\n// metricVecs.\ntype metricMap struct {\n\tmtx sync.RWMutex // Protects metrics.\n\tmetrics map[uint64][]metricWithLabelValues\n\tdesc *Desc\n\tnewMetric func(labelValues ...string) Metric\n}\n\n// Describe implements Collector. It will send exactly one Desc to the provided\n// channel.\nfunc (m *metricMap) Describe(ch chan<- *Desc) {\n\tch <- m.desc\n}\n\n// Collect implements Collector.\nfunc (m *metricMap) Collect(ch chan<- Metric) {\n\tm.mtx.RLock()\n\tdefer m.mtx.RUnlock()\n\n\tfor _, metrics := range m.metrics {\n\t\tfor _, metric := range metrics {\n\t\t\tch <- metric.metric\n\t\t}\n\t}\n}\n\n// Reset deletes all metrics in this vector.\nfunc (m *metricMap) Reset() {\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\n\tfor h := range m.metrics {\n\t\tdelete(m.metrics, h)\n\t}\n}\n\n// deleteByHashWithLabelValues removes the metric from the hash bucket h. If\n// there are multiple matches in the bucket, use lvs to select a metric and\n// remove only that metric.\nfunc (m *metricMap) deleteByHashWithLabelValues(\n\th uint64, lvs []string, curry []curriedLabelValue,\n) bool {\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\n\tmetrics, ok := m.metrics[h]\n\tif !ok {\n\t\treturn false\n\t}\n\n\ti := findMetricWithLabelValues(metrics, lvs, curry)\n\tif i >= len(metrics) {\n\t\treturn false\n\t}\n\n\tif len(metrics) > 1 {\n\t\told := metrics\n\t\tm.metrics[h] = append(metrics[:i], metrics[i+1:]...)\n\t\told[len(old)-1] = metricWithLabelValues{}\n\t} else {\n\t\tdelete(m.metrics, h)\n\t}\n\treturn true\n}\n\n// deleteByHashWithLabels removes the metric from the hash bucket h. If there\n// are multiple matches in the bucket, use lvs to select a metric and remove\n// only that metric.\nfunc (m *metricMap) deleteByHashWithLabels(\n\th uint64, labels Labels, curry []curriedLabelValue,\n) bool {\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\n\tmetrics, ok := m.metrics[h]\n\tif !ok {\n\t\treturn false\n\t}\n\ti := findMetricWithLabels(m.desc, metrics, labels, curry)\n\tif i >= len(metrics) {\n\t\treturn false\n\t}\n\n\tif len(metrics) > 1 {\n\t\told := metrics\n\t\tm.metrics[h] = append(metrics[:i], metrics[i+1:]...)\n\t\told[len(old)-1] = metricWithLabelValues{}\n\t} else {\n\t\tdelete(m.metrics, h)\n\t}\n\treturn true\n}\n\n// deleteByLabels deletes a metric if the given labels are present in the metric.\nfunc (m *metricMap) deleteByLabels(labels Labels, curry []curriedLabelValue) int {\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\n\tvar numDeleted int\n\n\tfor h, metrics := range m.metrics {\n\t\ti := findMetricWithPartialLabels(m.desc, metrics, labels, curry)\n\t\tif i >= len(metrics) {\n\t\t\t// Didn't find matching labels in this metric slice.\n\t\t\tcontinue\n\t\t}\n\t\tdelete(m.metrics, h)\n\t\tnumDeleted++\n\t}\n\n\treturn numDeleted\n}\n\n// findMetricWithPartialLabel returns the index of the matching metric or\n// len(metrics) if not found.\nfunc findMetricWithPartialLabels(\n\tdesc *Desc, metrics []metricWithLabelValues, labels Labels, curry []curriedLabelValue,\n) int {\n\tfor i, metric := range metrics {\n\t\tif matchPartialLabels(desc, metric.values, labels, curry) {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn len(metrics)\n}\n\n// indexOf searches the given slice of strings for the target string and returns\n// the index or len(items) as well as a boolean whether the search succeeded.\nfunc indexOf(target string, items []string) (int, bool) {\n\tfor i, l := range items {\n\t\tif l == target {\n\t\t\treturn i, true\n\t\t}\n\t}\n\treturn len(items), false\n}\n\n// valueMatchesVariableOrCurriedValue determines if a value was previously curried,\n// and returns whether it matches either the \"base\" value or the curried value accordingly.\n// It also indicates whether the match is against a curried or uncurried value.\nfunc valueMatchesVariableOrCurriedValue(targetValue string, index int, values []string, curry []curriedLabelValue) (bool, bool) {\n\tfor _, curriedValue := range curry {\n\t\tif curriedValue.index == index {\n\t\t\t// This label was curried. See if the curried value matches our target.\n\t\t\treturn curriedValue.value == targetValue, true\n\t\t}\n\t}\n\t// This label was not curried. See if the current value matches our target label.\n\treturn values[index] == targetValue, false\n}\n\n// matchPartialLabels searches the current metric and returns whether all of the target label:value pairs are present.\nfunc matchPartialLabels(desc *Desc, values []string, labels Labels, curry []curriedLabelValue) bool {\n\tfor l, v := range labels {\n\t\t// Check if the target label exists in our metrics and get the index.\n\t\tvarLabelIndex, validLabel := indexOf(l, desc.variableLabels)\n\t\tif validLabel {\n\t\t\t// Check the value of that label against the target value.\n\t\t\t// We don't consider curried values in partial matches.\n\t\t\tmatches, curried := valueMatchesVariableOrCurriedValue(v, varLabelIndex, values, curry)\n\t\t\tif matches && !curried {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t}\n\t\treturn false\n\t}\n\treturn true\n}\n\n// getOrCreateMetricWithLabelValues retrieves the metric by hash and label value\n// or creates it and returns the new one.\n//\n// This function holds the mutex.\nfunc (m *metricMap) getOrCreateMetricWithLabelValues(\n\thash uint64, lvs []string, curry []curriedLabelValue,\n) Metric {\n\tm.mtx.RLock()\n\tmetric, ok := m.getMetricWithHashAndLabelValues(hash, lvs, curry)\n\tm.mtx.RUnlock()\n\tif ok {\n\t\treturn metric\n\t}\n\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\tmetric, ok = m.getMetricWithHashAndLabelValues(hash, lvs, curry)\n\tif !ok {\n\t\tinlinedLVs := inlineLabelValues(lvs, curry)\n\t\tmetric = m.newMetric(inlinedLVs...)\n\t\tm.metrics[hash] = append(m.metrics[hash], metricWithLabelValues{values: inlinedLVs, metric: metric})\n\t}\n\treturn metric\n}\n\n// getOrCreateMetricWithLabelValues retrieves the metric by hash and label value\n// or creates it and returns the new one.\n//\n// This function holds the mutex.\nfunc (m *metricMap) getOrCreateMetricWithLabels(\n\thash uint64, labels Labels, curry []curriedLabelValue,\n) Metric {\n\tm.mtx.RLock()\n\tmetric, ok := m.getMetricWithHashAndLabels(hash, labels, curry)\n\tm.mtx.RUnlock()\n\tif ok {\n\t\treturn metric\n\t}\n\n\tm.mtx.Lock()\n\tdefer m.mtx.Unlock()\n\tmetric, ok = m.getMetricWithHashAndLabels(hash, labels, curry)\n\tif !ok {\n\t\tlvs := extractLabelValues(m.desc, labels, curry)\n\t\tmetric = m.newMetric(lvs...)\n\t\tm.metrics[hash] = append(m.metrics[hash], metricWithLabelValues{values: lvs, metric: metric})\n\t}\n\treturn metric\n}\n\n// getMetricWithHashAndLabelValues gets a metric while handling possible\n// collisions in the hash space. Must be called while holding the read mutex.\nfunc (m *metricMap) getMetricWithHashAndLabelValues(\n\th uint64, lvs []string, curry []curriedLabelValue,\n) (Metric, bool) {\n\tmetrics, ok := m.metrics[h]\n\tif ok {\n\t\tif i := findMetricWithLabelValues(metrics, lvs, curry); i < len(metrics) {\n\t\t\treturn metrics[i].metric, true\n\t\t}\n\t}\n\treturn nil, false\n}\n\n// getMetricWithHashAndLabels gets a metric while handling possible collisions in\n// the hash space. Must be called while holding read mutex.\nfunc (m *metricMap) getMetricWithHashAndLabels(\n\th uint64, labels Labels, curry []curriedLabelValue,\n) (Metric, bool) {\n\tmetrics, ok := m.metrics[h]\n\tif ok {\n\t\tif i := findMetricWithLabels(m.desc, metrics, labels, curry); i < len(metrics) {\n\t\t\treturn metrics[i].metric, true\n\t\t}\n\t}\n\treturn nil, false\n}\n\n// findMetricWithLabelValues returns the index of the matching metric or\n// len(metrics) if not found.\nfunc findMetricWithLabelValues(\n\tmetrics []metricWithLabelValues, lvs []string, curry []curriedLabelValue,\n) int {\n\tfor i, metric := range metrics {\n\t\tif matchLabelValues(metric.values, lvs, curry) {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn len(metrics)\n}\n\n// findMetricWithLabels returns the index of the matching metric or len(metrics)\n// if not found.\nfunc findMetricWithLabels(\n\tdesc *Desc, metrics []metricWithLabelValues, labels Labels, curry []curriedLabelValue,\n) int {\n\tfor i, metric := range metrics {\n\t\tif matchLabels(desc, metric.values, labels, curry) {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn len(metrics)\n}\n\nfunc matchLabelValues(values, lvs []string, curry []curriedLabelValue) bool {\n\tif len(values) != len(lvs)+len(curry) {\n\t\treturn false\n\t}\n\tvar iLVs, iCurry int\n\tfor i, v := range values {\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\tif v != curry[iCurry].value {\n\t\t\t\treturn false\n\t\t\t}\n\t\t\tiCurry++\n\t\t\tcontinue\n\t\t}\n\t\tif v != lvs[iLVs] {\n\t\t\treturn false\n\t\t}\n\t\tiLVs++\n\t}\n\treturn true\n}\n\nfunc matchLabels(desc *Desc, values []string, labels Labels, curry []curriedLabelValue) bool {\n\tif len(values) != len(labels)+len(curry) {\n\t\treturn false\n\t}\n\tiCurry := 0\n\tfor i, k := range desc.variableLabels {\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\tif values[i] != curry[iCurry].value {\n\t\t\t\treturn false\n\t\t\t}\n\t\t\tiCurry++\n\t\t\tcontinue\n\t\t}\n\t\tif values[i] != labels[k] {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\nfunc extractLabelValues(desc *Desc, labels Labels, curry []curriedLabelValue) []string {\n\tlabelValues := make([]string, len(labels)+len(curry))\n\tiCurry := 0\n\tfor i, k := range desc.variableLabels {\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\tlabelValues[i] = curry[iCurry].value\n\t\t\tiCurry++\n\t\t\tcontinue\n\t\t}\n\t\tlabelValues[i] = labels[k]\n\t}\n\treturn labelValues\n}\n\nfunc inlineLabelValues(lvs []string, curry []curriedLabelValue) []string {\n\tlabelValues := make([]string, len(lvs)+len(curry))\n\tvar iCurry, iLVs int\n\tfor i := range labelValues {\n\t\tif iCurry < len(curry) && curry[iCurry].index == i {\n\t\t\tlabelValues[i] = curry[iCurry].value\n\t\t\tiCurry++\n\t\t\tcontinue\n\t\t}\n\t\tlabelValues[i] = lvs[iLVs]\n\t\tiLVs++\n\t}\n\treturn labelValues\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_golang/prometheus/wrap.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage prometheus\n\nimport (\n\t\"fmt\"\n\t\"sort\"\n\n\t//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/golang/protobuf/proto\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/prometheus/client_golang/prometheus/internal\"\n)\n\n// WrapRegistererWith returns a Registerer wrapping the provided\n// Registerer. Collectors registered with the returned Registerer will be\n// registered with the wrapped Registerer in a modified way. The modified\n// Collector adds the provided Labels to all Metrics it collects (as\n// ConstLabels). The Metrics collected by the unmodified Collector must not\n// duplicate any of those labels. Wrapping a nil value is valid, resulting\n// in a no-op Registerer.\n//\n// WrapRegistererWith provides a way to add fixed labels to a subset of\n// Collectors. It should not be used to add fixed labels to all metrics\n// exposed. See also\n// https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels\n//\n// Conflicts between Collectors registered through the original Registerer with\n// Collectors registered through the wrapping Registerer will still be\n// detected. Any AlreadyRegisteredError returned by the Register method of\n// either Registerer will contain the ExistingCollector in the form it was\n// provided to the respective registry.\n//\n// The Collector example demonstrates a use of WrapRegistererWith.\nfunc WrapRegistererWith(labels Labels, reg Registerer) Registerer {\n\treturn &wrappingRegisterer{\n\t\twrappedRegisterer: reg,\n\t\tlabels: labels,\n\t}\n}\n\n// WrapRegistererWithPrefix returns a Registerer wrapping the provided\n// Registerer. Collectors registered with the returned Registerer will be\n// registered with the wrapped Registerer in a modified way. The modified\n// Collector adds the provided prefix to the name of all Metrics it collects.\n// Wrapping a nil value is valid, resulting in a no-op Registerer.\n//\n// WrapRegistererWithPrefix is useful to have one place to prefix all metrics of\n// a sub-system. To make this work, register metrics of the sub-system with the\n// wrapping Registerer returned by WrapRegistererWithPrefix. It is rarely useful\n// to use the same prefix for all metrics exposed. In particular, do not prefix\n// metric names that are standardized across applications, as that would break\n// horizontal monitoring, for example the metrics provided by the Go collector\n// (see NewGoCollector) and the process collector (see NewProcessCollector). (In\n// fact, those metrics are already prefixed with “go_” or “process_”,\n// respectively.)\n//\n// Conflicts between Collectors registered through the original Registerer with\n// Collectors registered through the wrapping Registerer will still be\n// detected. Any AlreadyRegisteredError returned by the Register method of\n// either Registerer will contain the ExistingCollector in the form it was\n// provided to the respective registry.\nfunc WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer {\n\treturn &wrappingRegisterer{\n\t\twrappedRegisterer: reg,\n\t\tprefix: prefix,\n\t}\n}\n\ntype wrappingRegisterer struct {\n\twrappedRegisterer Registerer\n\tprefix string\n\tlabels Labels\n}\n\nfunc (r *wrappingRegisterer) Register(c Collector) error {\n\tif r.wrappedRegisterer == nil {\n\t\treturn nil\n\t}\n\treturn r.wrappedRegisterer.Register(&wrappingCollector{\n\t\twrappedCollector: c,\n\t\tprefix: r.prefix,\n\t\tlabels: r.labels,\n\t})\n}\n\nfunc (r *wrappingRegisterer) MustRegister(cs ...Collector) {\n\tif r.wrappedRegisterer == nil {\n\t\treturn\n\t}\n\tfor _, c := range cs {\n\t\tif err := r.Register(c); err != nil {\n\t\t\tpanic(err)\n\t\t}\n\t}\n}\n\nfunc (r *wrappingRegisterer) Unregister(c Collector) bool {\n\tif r.wrappedRegisterer == nil {\n\t\treturn false\n\t}\n\treturn r.wrappedRegisterer.Unregister(&wrappingCollector{\n\t\twrappedCollector: c,\n\t\tprefix: r.prefix,\n\t\tlabels: r.labels,\n\t})\n}\n\ntype wrappingCollector struct {\n\twrappedCollector Collector\n\tprefix string\n\tlabels Labels\n}\n\nfunc (c *wrappingCollector) Collect(ch chan<- Metric) {\n\twrappedCh := make(chan Metric)\n\tgo func() {\n\t\tc.wrappedCollector.Collect(wrappedCh)\n\t\tclose(wrappedCh)\n\t}()\n\tfor m := range wrappedCh {\n\t\tch <- &wrappingMetric{\n\t\t\twrappedMetric: m,\n\t\t\tprefix: c.prefix,\n\t\t\tlabels: c.labels,\n\t\t}\n\t}\n}\n\nfunc (c *wrappingCollector) Describe(ch chan<- *Desc) {\n\twrappedCh := make(chan *Desc)\n\tgo func() {\n\t\tc.wrappedCollector.Describe(wrappedCh)\n\t\tclose(wrappedCh)\n\t}()\n\tfor desc := range wrappedCh {\n\t\tch <- wrapDesc(desc, c.prefix, c.labels)\n\t}\n}\n\nfunc (c *wrappingCollector) unwrapRecursively() Collector {\n\tswitch wc := c.wrappedCollector.(type) {\n\tcase *wrappingCollector:\n\t\treturn wc.unwrapRecursively()\n\tdefault:\n\t\treturn wc\n\t}\n}\n\ntype wrappingMetric struct {\n\twrappedMetric Metric\n\tprefix string\n\tlabels Labels\n}\n\nfunc (m *wrappingMetric) Desc() *Desc {\n\treturn wrapDesc(m.wrappedMetric.Desc(), m.prefix, m.labels)\n}\n\nfunc (m *wrappingMetric) Write(out *dto.Metric) error {\n\tif err := m.wrappedMetric.Write(out); err != nil {\n\t\treturn err\n\t}\n\tif len(m.labels) == 0 {\n\t\t// No wrapping labels.\n\t\treturn nil\n\t}\n\tfor ln, lv := range m.labels {\n\t\tout.Label = append(out.Label, &dto.LabelPair{\n\t\t\tName: proto.String(ln),\n\t\t\tValue: proto.String(lv),\n\t\t})\n\t}\n\tsort.Sort(internal.LabelPairSorter(out.Label))\n\treturn nil\n}\n\nfunc wrapDesc(desc *Desc, prefix string, labels Labels) *Desc {\n\tconstLabels := Labels{}\n\tfor _, lp := range desc.constLabelPairs {\n\t\tconstLabels[*lp.Name] = *lp.Value\n\t}\n\tfor ln, lv := range labels {\n\t\tif _, alreadyUsed := constLabels[ln]; alreadyUsed {\n\t\t\treturn &Desc{\n\t\t\t\tfqName: desc.fqName,\n\t\t\t\thelp: desc.help,\n\t\t\t\tvariableLabels: desc.variableLabels,\n\t\t\t\tconstLabelPairs: desc.constLabelPairs,\n\t\t\t\terr: fmt.Errorf(\"attempted wrapping with already existing label name %q\", ln),\n\t\t\t}\n\t\t}\n\t\tconstLabels[ln] = lv\n\t}\n\t// NewDesc will do remaining validations.\n\tnewDesc := NewDesc(prefix+desc.fqName, desc.help, desc.variableLabels, constLabels)\n\t// Propagate errors if there was any. This will override any errer\n\t// created by NewDesc above, i.e. earlier errors get precedence.\n\tif desc.err != nil {\n\t\tnewDesc.err = desc.err\n\t}\n\treturn newDesc\n}\n"
},
{
"path": "vendor/github.com/prometheus/client_model/LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/prometheus/client_model/NOTICE",
"content": "Data model artifacts for Prometheus.\nCopyright 2012-2015 The Prometheus Authors\n\nThis product includes software developed at\nSoundCloud Ltd. (http://soundcloud.com/).\n"
},
{
"path": "vendor/github.com/prometheus/client_model/go/metrics.pb.go",
"content": "// Code generated by protoc-gen-go. DO NOT EDIT.\n// source: io/prometheus/client/metrics.proto\n\npackage io_prometheus_client\n\nimport (\n\tfmt \"fmt\"\n\tproto \"github.com/golang/protobuf/proto\"\n\ttimestamp \"github.com/golang/protobuf/ptypes/timestamp\"\n\tmath \"math\"\n)\n\n// Reference imports to suppress errors if they are not otherwise used.\nvar _ = proto.Marshal\nvar _ = fmt.Errorf\nvar _ = math.Inf\n\n// This is a compile-time assertion to ensure that this generated file\n// is compatible with the proto package it is being compiled against.\n// A compilation error at this line likely means your copy of the\n// proto package needs to be updated.\nconst _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package\n\ntype MetricType int32\n\nconst (\n\t// COUNTER must use the Metric field \"counter\".\n\tMetricType_COUNTER MetricType = 0\n\t// GAUGE must use the Metric field \"gauge\".\n\tMetricType_GAUGE MetricType = 1\n\t// SUMMARY must use the Metric field \"summary\".\n\tMetricType_SUMMARY MetricType = 2\n\t// UNTYPED must use the Metric field \"untyped\".\n\tMetricType_UNTYPED MetricType = 3\n\t// HISTOGRAM must use the Metric field \"histogram\".\n\tMetricType_HISTOGRAM MetricType = 4\n\t// GAUGE_HISTOGRAM must use the Metric field \"histogram\".\n\tMetricType_GAUGE_HISTOGRAM MetricType = 5\n)\n\nvar MetricType_name = map[int32]string{\n\t0: \"COUNTER\",\n\t1: \"GAUGE\",\n\t2: \"SUMMARY\",\n\t3: \"UNTYPED\",\n\t4: \"HISTOGRAM\",\n\t5: \"GAUGE_HISTOGRAM\",\n}\n\nvar MetricType_value = map[string]int32{\n\t\"COUNTER\": 0,\n\t\"GAUGE\": 1,\n\t\"SUMMARY\": 2,\n\t\"UNTYPED\": 3,\n\t\"HISTOGRAM\": 4,\n\t\"GAUGE_HISTOGRAM\": 5,\n}\n\nfunc (x MetricType) Enum() *MetricType {\n\tp := new(MetricType)\n\t*p = x\n\treturn p\n}\n\nfunc (x MetricType) String() string {\n\treturn proto.EnumName(MetricType_name, int32(x))\n}\n\nfunc (x *MetricType) UnmarshalJSON(data []byte) error {\n\tvalue, err := proto.UnmarshalJSONEnum(MetricType_value, data, \"MetricType\")\n\tif err != nil {\n\t\treturn err\n\t}\n\t*x = MetricType(value)\n\treturn nil\n}\n\nfunc (MetricType) EnumDescriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{0}\n}\n\ntype LabelPair struct {\n\tName *string `protobuf:\"bytes,1,opt,name=name\" json:\"name,omitempty\"`\n\tValue *string `protobuf:\"bytes,2,opt,name=value\" json:\"value,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *LabelPair) Reset() { *m = LabelPair{} }\nfunc (m *LabelPair) String() string { return proto.CompactTextString(m) }\nfunc (*LabelPair) ProtoMessage() {}\nfunc (*LabelPair) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{0}\n}\n\nfunc (m *LabelPair) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_LabelPair.Unmarshal(m, b)\n}\nfunc (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_LabelPair.Marshal(b, m, deterministic)\n}\nfunc (m *LabelPair) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_LabelPair.Merge(m, src)\n}\nfunc (m *LabelPair) XXX_Size() int {\n\treturn xxx_messageInfo_LabelPair.Size(m)\n}\nfunc (m *LabelPair) XXX_DiscardUnknown() {\n\txxx_messageInfo_LabelPair.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_LabelPair proto.InternalMessageInfo\n\nfunc (m *LabelPair) GetName() string {\n\tif m != nil && m.Name != nil {\n\t\treturn *m.Name\n\t}\n\treturn \"\"\n}\n\nfunc (m *LabelPair) GetValue() string {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn \"\"\n}\n\ntype Gauge struct {\n\tValue *float64 `protobuf:\"fixed64,1,opt,name=value\" json:\"value,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Gauge) Reset() { *m = Gauge{} }\nfunc (m *Gauge) String() string { return proto.CompactTextString(m) }\nfunc (*Gauge) ProtoMessage() {}\nfunc (*Gauge) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{1}\n}\n\nfunc (m *Gauge) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Gauge.Unmarshal(m, b)\n}\nfunc (m *Gauge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Gauge.Marshal(b, m, deterministic)\n}\nfunc (m *Gauge) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Gauge.Merge(m, src)\n}\nfunc (m *Gauge) XXX_Size() int {\n\treturn xxx_messageInfo_Gauge.Size(m)\n}\nfunc (m *Gauge) XXX_DiscardUnknown() {\n\txxx_messageInfo_Gauge.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Gauge proto.InternalMessageInfo\n\nfunc (m *Gauge) GetValue() float64 {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn 0\n}\n\ntype Counter struct {\n\tValue *float64 `protobuf:\"fixed64,1,opt,name=value\" json:\"value,omitempty\"`\n\tExemplar *Exemplar `protobuf:\"bytes,2,opt,name=exemplar\" json:\"exemplar,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Counter) Reset() { *m = Counter{} }\nfunc (m *Counter) String() string { return proto.CompactTextString(m) }\nfunc (*Counter) ProtoMessage() {}\nfunc (*Counter) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{2}\n}\n\nfunc (m *Counter) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Counter.Unmarshal(m, b)\n}\nfunc (m *Counter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Counter.Marshal(b, m, deterministic)\n}\nfunc (m *Counter) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Counter.Merge(m, src)\n}\nfunc (m *Counter) XXX_Size() int {\n\treturn xxx_messageInfo_Counter.Size(m)\n}\nfunc (m *Counter) XXX_DiscardUnknown() {\n\txxx_messageInfo_Counter.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Counter proto.InternalMessageInfo\n\nfunc (m *Counter) GetValue() float64 {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn 0\n}\n\nfunc (m *Counter) GetExemplar() *Exemplar {\n\tif m != nil {\n\t\treturn m.Exemplar\n\t}\n\treturn nil\n}\n\ntype Quantile struct {\n\tQuantile *float64 `protobuf:\"fixed64,1,opt,name=quantile\" json:\"quantile,omitempty\"`\n\tValue *float64 `protobuf:\"fixed64,2,opt,name=value\" json:\"value,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Quantile) Reset() { *m = Quantile{} }\nfunc (m *Quantile) String() string { return proto.CompactTextString(m) }\nfunc (*Quantile) ProtoMessage() {}\nfunc (*Quantile) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{3}\n}\n\nfunc (m *Quantile) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Quantile.Unmarshal(m, b)\n}\nfunc (m *Quantile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Quantile.Marshal(b, m, deterministic)\n}\nfunc (m *Quantile) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Quantile.Merge(m, src)\n}\nfunc (m *Quantile) XXX_Size() int {\n\treturn xxx_messageInfo_Quantile.Size(m)\n}\nfunc (m *Quantile) XXX_DiscardUnknown() {\n\txxx_messageInfo_Quantile.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Quantile proto.InternalMessageInfo\n\nfunc (m *Quantile) GetQuantile() float64 {\n\tif m != nil && m.Quantile != nil {\n\t\treturn *m.Quantile\n\t}\n\treturn 0\n}\n\nfunc (m *Quantile) GetValue() float64 {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn 0\n}\n\ntype Summary struct {\n\tSampleCount *uint64 `protobuf:\"varint,1,opt,name=sample_count,json=sampleCount\" json:\"sample_count,omitempty\"`\n\tSampleSum *float64 `protobuf:\"fixed64,2,opt,name=sample_sum,json=sampleSum\" json:\"sample_sum,omitempty\"`\n\tQuantile []*Quantile `protobuf:\"bytes,3,rep,name=quantile\" json:\"quantile,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Summary) Reset() { *m = Summary{} }\nfunc (m *Summary) String() string { return proto.CompactTextString(m) }\nfunc (*Summary) ProtoMessage() {}\nfunc (*Summary) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{4}\n}\n\nfunc (m *Summary) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Summary.Unmarshal(m, b)\n}\nfunc (m *Summary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Summary.Marshal(b, m, deterministic)\n}\nfunc (m *Summary) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Summary.Merge(m, src)\n}\nfunc (m *Summary) XXX_Size() int {\n\treturn xxx_messageInfo_Summary.Size(m)\n}\nfunc (m *Summary) XXX_DiscardUnknown() {\n\txxx_messageInfo_Summary.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Summary proto.InternalMessageInfo\n\nfunc (m *Summary) GetSampleCount() uint64 {\n\tif m != nil && m.SampleCount != nil {\n\t\treturn *m.SampleCount\n\t}\n\treturn 0\n}\n\nfunc (m *Summary) GetSampleSum() float64 {\n\tif m != nil && m.SampleSum != nil {\n\t\treturn *m.SampleSum\n\t}\n\treturn 0\n}\n\nfunc (m *Summary) GetQuantile() []*Quantile {\n\tif m != nil {\n\t\treturn m.Quantile\n\t}\n\treturn nil\n}\n\ntype Untyped struct {\n\tValue *float64 `protobuf:\"fixed64,1,opt,name=value\" json:\"value,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Untyped) Reset() { *m = Untyped{} }\nfunc (m *Untyped) String() string { return proto.CompactTextString(m) }\nfunc (*Untyped) ProtoMessage() {}\nfunc (*Untyped) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{5}\n}\n\nfunc (m *Untyped) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Untyped.Unmarshal(m, b)\n}\nfunc (m *Untyped) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Untyped.Marshal(b, m, deterministic)\n}\nfunc (m *Untyped) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Untyped.Merge(m, src)\n}\nfunc (m *Untyped) XXX_Size() int {\n\treturn xxx_messageInfo_Untyped.Size(m)\n}\nfunc (m *Untyped) XXX_DiscardUnknown() {\n\txxx_messageInfo_Untyped.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Untyped proto.InternalMessageInfo\n\nfunc (m *Untyped) GetValue() float64 {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn 0\n}\n\ntype Histogram struct {\n\tSampleCount *uint64 `protobuf:\"varint,1,opt,name=sample_count,json=sampleCount\" json:\"sample_count,omitempty\"`\n\tSampleCountFloat *float64 `protobuf:\"fixed64,4,opt,name=sample_count_float,json=sampleCountFloat\" json:\"sample_count_float,omitempty\"`\n\tSampleSum *float64 `protobuf:\"fixed64,2,opt,name=sample_sum,json=sampleSum\" json:\"sample_sum,omitempty\"`\n\t// Buckets for the conventional histogram.\n\tBucket []*Bucket `protobuf:\"bytes,3,rep,name=bucket\" json:\"bucket,omitempty\"`\n\t// schema defines the bucket schema. Currently, valid numbers are -4 <= n <= 8.\n\t// They are all for base-2 bucket schemas, where 1 is a bucket boundary in each case, and\n\t// then each power of two is divided into 2^n logarithmic buckets.\n\t// Or in other words, each bucket boundary is the previous boundary times 2^(2^-n).\n\t// In the future, more bucket schemas may be added using numbers < -4 or > 8.\n\tSchema *int32 `protobuf:\"zigzag32,5,opt,name=schema\" json:\"schema,omitempty\"`\n\tZeroThreshold *float64 `protobuf:\"fixed64,6,opt,name=zero_threshold,json=zeroThreshold\" json:\"zero_threshold,omitempty\"`\n\tZeroCount *uint64 `protobuf:\"varint,7,opt,name=zero_count,json=zeroCount\" json:\"zero_count,omitempty\"`\n\tZeroCountFloat *float64 `protobuf:\"fixed64,8,opt,name=zero_count_float,json=zeroCountFloat\" json:\"zero_count_float,omitempty\"`\n\t// Negative buckets for the native histogram.\n\tNegativeSpan []*BucketSpan `protobuf:\"bytes,9,rep,name=negative_span,json=negativeSpan\" json:\"negative_span,omitempty\"`\n\t// Use either \"negative_delta\" or \"negative_count\", the former for\n\t// regular histograms with integer counts, the latter for float\n\t// histograms.\n\tNegativeDelta []int64 `protobuf:\"zigzag64,10,rep,name=negative_delta,json=negativeDelta\" json:\"negative_delta,omitempty\"`\n\tNegativeCount []float64 `protobuf:\"fixed64,11,rep,name=negative_count,json=negativeCount\" json:\"negative_count,omitempty\"`\n\t// Positive buckets for the native histogram.\n\tPositiveSpan []*BucketSpan `protobuf:\"bytes,12,rep,name=positive_span,json=positiveSpan\" json:\"positive_span,omitempty\"`\n\t// Use either \"positive_delta\" or \"positive_count\", the former for\n\t// regular histograms with integer counts, the latter for float\n\t// histograms.\n\tPositiveDelta []int64 `protobuf:\"zigzag64,13,rep,name=positive_delta,json=positiveDelta\" json:\"positive_delta,omitempty\"`\n\tPositiveCount []float64 `protobuf:\"fixed64,14,rep,name=positive_count,json=positiveCount\" json:\"positive_count,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Histogram) Reset() { *m = Histogram{} }\nfunc (m *Histogram) String() string { return proto.CompactTextString(m) }\nfunc (*Histogram) ProtoMessage() {}\nfunc (*Histogram) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{6}\n}\n\nfunc (m *Histogram) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Histogram.Unmarshal(m, b)\n}\nfunc (m *Histogram) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Histogram.Marshal(b, m, deterministic)\n}\nfunc (m *Histogram) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Histogram.Merge(m, src)\n}\nfunc (m *Histogram) XXX_Size() int {\n\treturn xxx_messageInfo_Histogram.Size(m)\n}\nfunc (m *Histogram) XXX_DiscardUnknown() {\n\txxx_messageInfo_Histogram.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Histogram proto.InternalMessageInfo\n\nfunc (m *Histogram) GetSampleCount() uint64 {\n\tif m != nil && m.SampleCount != nil {\n\t\treturn *m.SampleCount\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetSampleCountFloat() float64 {\n\tif m != nil && m.SampleCountFloat != nil {\n\t\treturn *m.SampleCountFloat\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetSampleSum() float64 {\n\tif m != nil && m.SampleSum != nil {\n\t\treturn *m.SampleSum\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetBucket() []*Bucket {\n\tif m != nil {\n\t\treturn m.Bucket\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetSchema() int32 {\n\tif m != nil && m.Schema != nil {\n\t\treturn *m.Schema\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetZeroThreshold() float64 {\n\tif m != nil && m.ZeroThreshold != nil {\n\t\treturn *m.ZeroThreshold\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetZeroCount() uint64 {\n\tif m != nil && m.ZeroCount != nil {\n\t\treturn *m.ZeroCount\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetZeroCountFloat() float64 {\n\tif m != nil && m.ZeroCountFloat != nil {\n\t\treturn *m.ZeroCountFloat\n\t}\n\treturn 0\n}\n\nfunc (m *Histogram) GetNegativeSpan() []*BucketSpan {\n\tif m != nil {\n\t\treturn m.NegativeSpan\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetNegativeDelta() []int64 {\n\tif m != nil {\n\t\treturn m.NegativeDelta\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetNegativeCount() []float64 {\n\tif m != nil {\n\t\treturn m.NegativeCount\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetPositiveSpan() []*BucketSpan {\n\tif m != nil {\n\t\treturn m.PositiveSpan\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetPositiveDelta() []int64 {\n\tif m != nil {\n\t\treturn m.PositiveDelta\n\t}\n\treturn nil\n}\n\nfunc (m *Histogram) GetPositiveCount() []float64 {\n\tif m != nil {\n\t\treturn m.PositiveCount\n\t}\n\treturn nil\n}\n\n// A Bucket of a conventional histogram, each of which is treated as\n// an individual counter-like time series by Prometheus.\ntype Bucket struct {\n\tCumulativeCount *uint64 `protobuf:\"varint,1,opt,name=cumulative_count,json=cumulativeCount\" json:\"cumulative_count,omitempty\"`\n\tCumulativeCountFloat *float64 `protobuf:\"fixed64,4,opt,name=cumulative_count_float,json=cumulativeCountFloat\" json:\"cumulative_count_float,omitempty\"`\n\tUpperBound *float64 `protobuf:\"fixed64,2,opt,name=upper_bound,json=upperBound\" json:\"upper_bound,omitempty\"`\n\tExemplar *Exemplar `protobuf:\"bytes,3,opt,name=exemplar\" json:\"exemplar,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Bucket) Reset() { *m = Bucket{} }\nfunc (m *Bucket) String() string { return proto.CompactTextString(m) }\nfunc (*Bucket) ProtoMessage() {}\nfunc (*Bucket) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{7}\n}\n\nfunc (m *Bucket) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Bucket.Unmarshal(m, b)\n}\nfunc (m *Bucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Bucket.Marshal(b, m, deterministic)\n}\nfunc (m *Bucket) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Bucket.Merge(m, src)\n}\nfunc (m *Bucket) XXX_Size() int {\n\treturn xxx_messageInfo_Bucket.Size(m)\n}\nfunc (m *Bucket) XXX_DiscardUnknown() {\n\txxx_messageInfo_Bucket.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Bucket proto.InternalMessageInfo\n\nfunc (m *Bucket) GetCumulativeCount() uint64 {\n\tif m != nil && m.CumulativeCount != nil {\n\t\treturn *m.CumulativeCount\n\t}\n\treturn 0\n}\n\nfunc (m *Bucket) GetCumulativeCountFloat() float64 {\n\tif m != nil && m.CumulativeCountFloat != nil {\n\t\treturn *m.CumulativeCountFloat\n\t}\n\treturn 0\n}\n\nfunc (m *Bucket) GetUpperBound() float64 {\n\tif m != nil && m.UpperBound != nil {\n\t\treturn *m.UpperBound\n\t}\n\treturn 0\n}\n\nfunc (m *Bucket) GetExemplar() *Exemplar {\n\tif m != nil {\n\t\treturn m.Exemplar\n\t}\n\treturn nil\n}\n\n// A BucketSpan defines a number of consecutive buckets in a native\n// histogram with their offset. Logically, it would be more\n// straightforward to include the bucket counts in the Span. However,\n// the protobuf representation is more compact in the way the data is\n// structured here (with all the buckets in a single array separate\n// from the Spans).\ntype BucketSpan struct {\n\tOffset *int32 `protobuf:\"zigzag32,1,opt,name=offset\" json:\"offset,omitempty\"`\n\tLength *uint32 `protobuf:\"varint,2,opt,name=length\" json:\"length,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *BucketSpan) Reset() { *m = BucketSpan{} }\nfunc (m *BucketSpan) String() string { return proto.CompactTextString(m) }\nfunc (*BucketSpan) ProtoMessage() {}\nfunc (*BucketSpan) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{8}\n}\n\nfunc (m *BucketSpan) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_BucketSpan.Unmarshal(m, b)\n}\nfunc (m *BucketSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_BucketSpan.Marshal(b, m, deterministic)\n}\nfunc (m *BucketSpan) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_BucketSpan.Merge(m, src)\n}\nfunc (m *BucketSpan) XXX_Size() int {\n\treturn xxx_messageInfo_BucketSpan.Size(m)\n}\nfunc (m *BucketSpan) XXX_DiscardUnknown() {\n\txxx_messageInfo_BucketSpan.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_BucketSpan proto.InternalMessageInfo\n\nfunc (m *BucketSpan) GetOffset() int32 {\n\tif m != nil && m.Offset != nil {\n\t\treturn *m.Offset\n\t}\n\treturn 0\n}\n\nfunc (m *BucketSpan) GetLength() uint32 {\n\tif m != nil && m.Length != nil {\n\t\treturn *m.Length\n\t}\n\treturn 0\n}\n\ntype Exemplar struct {\n\tLabel []*LabelPair `protobuf:\"bytes,1,rep,name=label\" json:\"label,omitempty\"`\n\tValue *float64 `protobuf:\"fixed64,2,opt,name=value\" json:\"value,omitempty\"`\n\tTimestamp *timestamp.Timestamp `protobuf:\"bytes,3,opt,name=timestamp\" json:\"timestamp,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Exemplar) Reset() { *m = Exemplar{} }\nfunc (m *Exemplar) String() string { return proto.CompactTextString(m) }\nfunc (*Exemplar) ProtoMessage() {}\nfunc (*Exemplar) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{9}\n}\n\nfunc (m *Exemplar) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Exemplar.Unmarshal(m, b)\n}\nfunc (m *Exemplar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Exemplar.Marshal(b, m, deterministic)\n}\nfunc (m *Exemplar) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Exemplar.Merge(m, src)\n}\nfunc (m *Exemplar) XXX_Size() int {\n\treturn xxx_messageInfo_Exemplar.Size(m)\n}\nfunc (m *Exemplar) XXX_DiscardUnknown() {\n\txxx_messageInfo_Exemplar.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Exemplar proto.InternalMessageInfo\n\nfunc (m *Exemplar) GetLabel() []*LabelPair {\n\tif m != nil {\n\t\treturn m.Label\n\t}\n\treturn nil\n}\n\nfunc (m *Exemplar) GetValue() float64 {\n\tif m != nil && m.Value != nil {\n\t\treturn *m.Value\n\t}\n\treturn 0\n}\n\nfunc (m *Exemplar) GetTimestamp() *timestamp.Timestamp {\n\tif m != nil {\n\t\treturn m.Timestamp\n\t}\n\treturn nil\n}\n\ntype Metric struct {\n\tLabel []*LabelPair `protobuf:\"bytes,1,rep,name=label\" json:\"label,omitempty\"`\n\tGauge *Gauge `protobuf:\"bytes,2,opt,name=gauge\" json:\"gauge,omitempty\"`\n\tCounter *Counter `protobuf:\"bytes,3,opt,name=counter\" json:\"counter,omitempty\"`\n\tSummary *Summary `protobuf:\"bytes,4,opt,name=summary\" json:\"summary,omitempty\"`\n\tUntyped *Untyped `protobuf:\"bytes,5,opt,name=untyped\" json:\"untyped,omitempty\"`\n\tHistogram *Histogram `protobuf:\"bytes,7,opt,name=histogram\" json:\"histogram,omitempty\"`\n\tTimestampMs *int64 `protobuf:\"varint,6,opt,name=timestamp_ms,json=timestampMs\" json:\"timestamp_ms,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *Metric) Reset() { *m = Metric{} }\nfunc (m *Metric) String() string { return proto.CompactTextString(m) }\nfunc (*Metric) ProtoMessage() {}\nfunc (*Metric) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{10}\n}\n\nfunc (m *Metric) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_Metric.Unmarshal(m, b)\n}\nfunc (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_Metric.Marshal(b, m, deterministic)\n}\nfunc (m *Metric) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_Metric.Merge(m, src)\n}\nfunc (m *Metric) XXX_Size() int {\n\treturn xxx_messageInfo_Metric.Size(m)\n}\nfunc (m *Metric) XXX_DiscardUnknown() {\n\txxx_messageInfo_Metric.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_Metric proto.InternalMessageInfo\n\nfunc (m *Metric) GetLabel() []*LabelPair {\n\tif m != nil {\n\t\treturn m.Label\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetGauge() *Gauge {\n\tif m != nil {\n\t\treturn m.Gauge\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetCounter() *Counter {\n\tif m != nil {\n\t\treturn m.Counter\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetSummary() *Summary {\n\tif m != nil {\n\t\treturn m.Summary\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetUntyped() *Untyped {\n\tif m != nil {\n\t\treturn m.Untyped\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetHistogram() *Histogram {\n\tif m != nil {\n\t\treturn m.Histogram\n\t}\n\treturn nil\n}\n\nfunc (m *Metric) GetTimestampMs() int64 {\n\tif m != nil && m.TimestampMs != nil {\n\t\treturn *m.TimestampMs\n\t}\n\treturn 0\n}\n\ntype MetricFamily struct {\n\tName *string `protobuf:\"bytes,1,opt,name=name\" json:\"name,omitempty\"`\n\tHelp *string `protobuf:\"bytes,2,opt,name=help\" json:\"help,omitempty\"`\n\tType *MetricType `protobuf:\"varint,3,opt,name=type,enum=io.prometheus.client.MetricType\" json:\"type,omitempty\"`\n\tMetric []*Metric `protobuf:\"bytes,4,rep,name=metric\" json:\"metric,omitempty\"`\n\tXXX_NoUnkeyedLiteral struct{} `json:\"-\"`\n\tXXX_unrecognized []byte `json:\"-\"`\n\tXXX_sizecache int32 `json:\"-\"`\n}\n\nfunc (m *MetricFamily) Reset() { *m = MetricFamily{} }\nfunc (m *MetricFamily) String() string { return proto.CompactTextString(m) }\nfunc (*MetricFamily) ProtoMessage() {}\nfunc (*MetricFamily) Descriptor() ([]byte, []int) {\n\treturn fileDescriptor_d1e5ddb18987a258, []int{11}\n}\n\nfunc (m *MetricFamily) XXX_Unmarshal(b []byte) error {\n\treturn xxx_messageInfo_MetricFamily.Unmarshal(m, b)\n}\nfunc (m *MetricFamily) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {\n\treturn xxx_messageInfo_MetricFamily.Marshal(b, m, deterministic)\n}\nfunc (m *MetricFamily) XXX_Merge(src proto.Message) {\n\txxx_messageInfo_MetricFamily.Merge(m, src)\n}\nfunc (m *MetricFamily) XXX_Size() int {\n\treturn xxx_messageInfo_MetricFamily.Size(m)\n}\nfunc (m *MetricFamily) XXX_DiscardUnknown() {\n\txxx_messageInfo_MetricFamily.DiscardUnknown(m)\n}\n\nvar xxx_messageInfo_MetricFamily proto.InternalMessageInfo\n\nfunc (m *MetricFamily) GetName() string {\n\tif m != nil && m.Name != nil {\n\t\treturn *m.Name\n\t}\n\treturn \"\"\n}\n\nfunc (m *MetricFamily) GetHelp() string {\n\tif m != nil && m.Help != nil {\n\t\treturn *m.Help\n\t}\n\treturn \"\"\n}\n\nfunc (m *MetricFamily) GetType() MetricType {\n\tif m != nil && m.Type != nil {\n\t\treturn *m.Type\n\t}\n\treturn MetricType_COUNTER\n}\n\nfunc (m *MetricFamily) GetMetric() []*Metric {\n\tif m != nil {\n\t\treturn m.Metric\n\t}\n\treturn nil\n}\n\nfunc init() {\n\tproto.RegisterEnum(\"io.prometheus.client.MetricType\", MetricType_name, MetricType_value)\n\tproto.RegisterType((*LabelPair)(nil), \"io.prometheus.client.LabelPair\")\n\tproto.RegisterType((*Gauge)(nil), \"io.prometheus.client.Gauge\")\n\tproto.RegisterType((*Counter)(nil), \"io.prometheus.client.Counter\")\n\tproto.RegisterType((*Quantile)(nil), \"io.prometheus.client.Quantile\")\n\tproto.RegisterType((*Summary)(nil), \"io.prometheus.client.Summary\")\n\tproto.RegisterType((*Untyped)(nil), \"io.prometheus.client.Untyped\")\n\tproto.RegisterType((*Histogram)(nil), \"io.prometheus.client.Histogram\")\n\tproto.RegisterType((*Bucket)(nil), \"io.prometheus.client.Bucket\")\n\tproto.RegisterType((*BucketSpan)(nil), \"io.prometheus.client.BucketSpan\")\n\tproto.RegisterType((*Exemplar)(nil), \"io.prometheus.client.Exemplar\")\n\tproto.RegisterType((*Metric)(nil), \"io.prometheus.client.Metric\")\n\tproto.RegisterType((*MetricFamily)(nil), \"io.prometheus.client.MetricFamily\")\n}\n\nfunc init() {\n\tproto.RegisterFile(\"io/prometheus/client/metrics.proto\", fileDescriptor_d1e5ddb18987a258)\n}\n\nvar fileDescriptor_d1e5ddb18987a258 = []byte{\n\t// 896 bytes of a gzipped FileDescriptorProto\n\t0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x8e, 0xdb, 0x44,\n\t0x18, 0xc5, 0x9b, 0x5f, 0x7f, 0xd9, 0x6c, 0xd3, 0x61, 0x55, 0x59, 0x0b, 0xcb, 0x06, 0x4b, 0x48,\n\t0x0b, 0x42, 0x8e, 0x40, 0x5b, 0x81, 0x0a, 0x5c, 0xec, 0xb6, 0xe9, 0x16, 0x89, 0xb4, 0x65, 0x92,\n\t0x5c, 0x14, 0x2e, 0xac, 0x49, 0x32, 0xeb, 0x58, 0x78, 0x3c, 0xc6, 0x1e, 0x57, 0x2c, 0x2f, 0xc0,\n\t0x35, 0xaf, 0xc0, 0xc3, 0xf0, 0x22, 0x3c, 0x08, 0x68, 0xfe, 0xec, 0xdd, 0xe2, 0x94, 0xd2, 0x3b,\n\t0x7f, 0x67, 0xce, 0xf7, 0xcd, 0x39, 0xe3, 0xc9, 0x71, 0xc0, 0x8f, 0xf9, 0x24, 0xcb, 0x39, 0xa3,\n\t0x62, 0x4b, 0xcb, 0x62, 0xb2, 0x4e, 0x62, 0x9a, 0x8a, 0x09, 0xa3, 0x22, 0x8f, 0xd7, 0x45, 0x90,\n\t0xe5, 0x5c, 0x70, 0x74, 0x18, 0xf3, 0xa0, 0xe6, 0x04, 0x9a, 0x73, 0x74, 0x12, 0x71, 0x1e, 0x25,\n\t0x74, 0xa2, 0x38, 0xab, 0xf2, 0x6a, 0x22, 0x62, 0x46, 0x0b, 0x41, 0x58, 0xa6, 0xdb, 0xfc, 0xfb,\n\t0xe0, 0x7e, 0x47, 0x56, 0x34, 0x79, 0x4e, 0xe2, 0x1c, 0x21, 0x68, 0xa7, 0x84, 0x51, 0xcf, 0x19,\n\t0x3b, 0xa7, 0x2e, 0x56, 0xcf, 0xe8, 0x10, 0x3a, 0x2f, 0x49, 0x52, 0x52, 0x6f, 0x4f, 0x81, 0xba,\n\t0xf0, 0x8f, 0xa1, 0x73, 0x49, 0xca, 0xe8, 0xc6, 0xb2, 0xec, 0x71, 0xec, 0xf2, 0x8f, 0xd0, 0x7b,\n\t0xc8, 0xcb, 0x54, 0xd0, 0xbc, 0x99, 0x80, 0x1e, 0x40, 0x9f, 0xfe, 0x42, 0x59, 0x96, 0x90, 0x5c,\n\t0x0d, 0x1e, 0x7c, 0xfe, 0x41, 0xd0, 0x64, 0x20, 0x98, 0x1a, 0x16, 0xae, 0xf8, 0xfe, 0xd7, 0xd0,\n\t0xff, 0xbe, 0x24, 0xa9, 0x88, 0x13, 0x8a, 0x8e, 0xa0, 0xff, 0xb3, 0x79, 0x36, 0x1b, 0x54, 0xf5,\n\t0x6d, 0xe5, 0x95, 0xb4, 0xdf, 0x1c, 0xe8, 0xcd, 0x4b, 0xc6, 0x48, 0x7e, 0x8d, 0x3e, 0x84, 0xfd,\n\t0x82, 0xb0, 0x2c, 0xa1, 0xe1, 0x5a, 0xaa, 0x55, 0x13, 0xda, 0x78, 0xa0, 0x31, 0x65, 0x00, 0x1d,\n\t0x03, 0x18, 0x4a, 0x51, 0x32, 0x33, 0xc9, 0xd5, 0xc8, 0xbc, 0x64, 0xd2, 0x47, 0xb5, 0x7f, 0x6b,\n\t0xdc, 0xda, 0xed, 0xc3, 0x2a, 0xae, 0xf5, 0xf9, 0x27, 0xd0, 0x5b, 0xa6, 0xe2, 0x3a, 0xa3, 0x9b,\n\t0x1d, 0xa7, 0xf8, 0x57, 0x1b, 0xdc, 0x27, 0x71, 0x21, 0x78, 0x94, 0x13, 0xf6, 0x26, 0x62, 0x3f,\n\t0x05, 0x74, 0x93, 0x12, 0x5e, 0x25, 0x9c, 0x08, 0xaf, 0xad, 0x66, 0x8e, 0x6e, 0x10, 0x1f, 0x4b,\n\t0xfc, 0xbf, 0xac, 0x9d, 0x41, 0x77, 0x55, 0xae, 0x7f, 0xa2, 0xc2, 0x18, 0x7b, 0xbf, 0xd9, 0xd8,\n\t0x85, 0xe2, 0x60, 0xc3, 0x45, 0xf7, 0xa0, 0x5b, 0xac, 0xb7, 0x94, 0x11, 0xaf, 0x33, 0x76, 0x4e,\n\t0xef, 0x62, 0x53, 0xa1, 0x8f, 0xe0, 0xe0, 0x57, 0x9a, 0xf3, 0x50, 0x6c, 0x73, 0x5a, 0x6c, 0x79,\n\t0xb2, 0xf1, 0xba, 0x6a, 0xc3, 0xa1, 0x44, 0x17, 0x16, 0x94, 0x9a, 0x14, 0x4d, 0x5b, 0xec, 0x29,\n\t0x8b, 0xae, 0x44, 0xb4, 0xc1, 0x53, 0x18, 0xd5, 0xcb, 0xc6, 0x5e, 0x5f, 0xcd, 0x39, 0xa8, 0x48,\n\t0xda, 0xdc, 0x14, 0x86, 0x29, 0x8d, 0x88, 0x88, 0x5f, 0xd2, 0xb0, 0xc8, 0x48, 0xea, 0xb9, 0xca,\n\t0xc4, 0xf8, 0x75, 0x26, 0xe6, 0x19, 0x49, 0xf1, 0xbe, 0x6d, 0x93, 0x95, 0x94, 0x5d, 0x8d, 0xd9,\n\t0xd0, 0x44, 0x10, 0x0f, 0xc6, 0xad, 0x53, 0x84, 0xab, 0xe1, 0x8f, 0x24, 0x78, 0x8b, 0xa6, 0xa5,\n\t0x0f, 0xc6, 0x2d, 0xe9, 0xce, 0xa2, 0x5a, 0xfe, 0x14, 0x86, 0x19, 0x2f, 0xe2, 0x5a, 0xd4, 0xfe,\n\t0x9b, 0x8a, 0xb2, 0x6d, 0x56, 0x54, 0x35, 0x46, 0x8b, 0x1a, 0x6a, 0x51, 0x16, 0xad, 0x44, 0x55,\n\t0x34, 0x2d, 0xea, 0x40, 0x8b, 0xb2, 0xa8, 0x12, 0xe5, 0xff, 0xe9, 0x40, 0x57, 0x6f, 0x85, 0x3e,\n\t0x86, 0xd1, 0xba, 0x64, 0x65, 0x72, 0xd3, 0x88, 0xbe, 0x66, 0x77, 0x6a, 0x5c, 0x5b, 0x39, 0x83,\n\t0x7b, 0xaf, 0x52, 0x6f, 0x5d, 0xb7, 0xc3, 0x57, 0x1a, 0xf4, 0x5b, 0x39, 0x81, 0x41, 0x99, 0x65,\n\t0x34, 0x0f, 0x57, 0xbc, 0x4c, 0x37, 0xe6, 0xce, 0x81, 0x82, 0x2e, 0x24, 0x72, 0x2b, 0x17, 0x5a,\n\t0xff, 0x3b, 0x17, 0xa0, 0x3e, 0x32, 0x79, 0x11, 0xf9, 0xd5, 0x55, 0x41, 0xb5, 0x83, 0xbb, 0xd8,\n\t0x54, 0x12, 0x4f, 0x68, 0x1a, 0x89, 0xad, 0xda, 0x7d, 0x88, 0x4d, 0xe5, 0xff, 0xee, 0x40, 0xdf,\n\t0x0e, 0x45, 0xf7, 0xa1, 0x93, 0xc8, 0x54, 0xf4, 0x1c, 0xf5, 0x82, 0x4e, 0x9a, 0x35, 0x54, 0xc1,\n\t0x89, 0x35, 0xbb, 0x39, 0x71, 0xd0, 0x97, 0xe0, 0x56, 0xa9, 0x6b, 0x4c, 0x1d, 0x05, 0x3a, 0x97,\n\t0x03, 0x9b, 0xcb, 0xc1, 0xc2, 0x32, 0x70, 0x4d, 0xf6, 0xff, 0xde, 0x83, 0xee, 0x4c, 0xa5, 0xfc,\n\t0xdb, 0x2a, 0xfa, 0x0c, 0x3a, 0x91, 0xcc, 0x69, 0x13, 0xb2, 0xef, 0x35, 0xb7, 0xa9, 0x28, 0xc7,\n\t0x9a, 0x89, 0xbe, 0x80, 0xde, 0x5a, 0x67, 0xb7, 0x11, 0x7b, 0xdc, 0xdc, 0x64, 0x02, 0x1e, 0x5b,\n\t0xb6, 0x6c, 0x2c, 0x74, 0xb0, 0xaa, 0x3b, 0xb0, 0xb3, 0xd1, 0xa4, 0x2f, 0xb6, 0x6c, 0xd9, 0x58,\n\t0xea, 0x20, 0x54, 0xa1, 0xb1, 0xb3, 0xd1, 0xa4, 0x25, 0xb6, 0x6c, 0xf4, 0x0d, 0xb8, 0x5b, 0x9b,\n\t0x8f, 0x2a, 0x2c, 0x76, 0x1e, 0x4c, 0x15, 0xa3, 0xb8, 0xee, 0x90, 0x89, 0x5a, 0x9d, 0x75, 0xc8,\n\t0x0a, 0x95, 0x48, 0x2d, 0x3c, 0xa8, 0xb0, 0x59, 0xe1, 0xff, 0xe1, 0xc0, 0xbe, 0x7e, 0x03, 0x8f,\n\t0x09, 0x8b, 0x93, 0xeb, 0xc6, 0x4f, 0x24, 0x82, 0xf6, 0x96, 0x26, 0x99, 0xf9, 0x42, 0xaa, 0x67,\n\t0x74, 0x06, 0x6d, 0xa9, 0x51, 0x1d, 0xe1, 0xc1, 0xae, 0x5f, 0xb8, 0x9e, 0xbc, 0xb8, 0xce, 0x28,\n\t0x56, 0x6c, 0x99, 0xb9, 0xfa, 0xab, 0xee, 0xb5, 0x5f, 0x97, 0xb9, 0xba, 0x0f, 0x1b, 0xee, 0x27,\n\t0x2b, 0x80, 0x7a, 0x12, 0x1a, 0x40, 0xef, 0xe1, 0xb3, 0xe5, 0xd3, 0xc5, 0x14, 0x8f, 0xde, 0x41,\n\t0x2e, 0x74, 0x2e, 0xcf, 0x97, 0x97, 0xd3, 0x91, 0x23, 0xf1, 0xf9, 0x72, 0x36, 0x3b, 0xc7, 0x2f,\n\t0x46, 0x7b, 0xb2, 0x58, 0x3e, 0x5d, 0xbc, 0x78, 0x3e, 0x7d, 0x34, 0x6a, 0xa1, 0x21, 0xb8, 0x4f,\n\t0xbe, 0x9d, 0x2f, 0x9e, 0x5d, 0xe2, 0xf3, 0xd9, 0xa8, 0x8d, 0xde, 0x85, 0x3b, 0xaa, 0x27, 0xac,\n\t0xc1, 0xce, 0x05, 0x86, 0xc6, 0x3f, 0x18, 0x3f, 0x3c, 0x88, 0x62, 0xb1, 0x2d, 0x57, 0xc1, 0x9a,\n\t0xb3, 0x7f, 0xff, 0x45, 0x09, 0x19, 0xdf, 0xd0, 0x64, 0x12, 0xf1, 0xaf, 0x62, 0x1e, 0xd6, 0xab,\n\t0xa1, 0x5e, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0x16, 0x77, 0x81, 0x98, 0xd7, 0x08, 0x00, 0x00,\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/prometheus/common/NOTICE",
"content": "Common libraries shared by Prometheus Go components.\nCopyright 2015 The Prometheus Authors\n\nThis product includes software developed at\nSoundCloud Ltd. (http://soundcloud.com/).\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/decode.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage expfmt\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"mime\"\n\t\"net/http\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/matttproud/golang_protobuf_extensions/pbutil\"\n\t\"github.com/prometheus/common/model\"\n)\n\n// Decoder types decode an input stream into metric families.\ntype Decoder interface {\n\tDecode(*dto.MetricFamily) error\n}\n\n// DecodeOptions contains options used by the Decoder and in sample extraction.\ntype DecodeOptions struct {\n\t// Timestamp is added to each value from the stream that has no explicit timestamp set.\n\tTimestamp model.Time\n}\n\n// ResponseFormat extracts the correct format from a HTTP response header.\n// If no matching format can be found FormatUnknown is returned.\nfunc ResponseFormat(h http.Header) Format {\n\tct := h.Get(hdrContentType)\n\n\tmediatype, params, err := mime.ParseMediaType(ct)\n\tif err != nil {\n\t\treturn FmtUnknown\n\t}\n\n\tconst textType = \"text/plain\"\n\n\tswitch mediatype {\n\tcase ProtoType:\n\t\tif p, ok := params[\"proto\"]; ok && p != ProtoProtocol {\n\t\t\treturn FmtUnknown\n\t\t}\n\t\tif e, ok := params[\"encoding\"]; ok && e != \"delimited\" {\n\t\t\treturn FmtUnknown\n\t\t}\n\t\treturn FmtProtoDelim\n\n\tcase textType:\n\t\tif v, ok := params[\"version\"]; ok && v != TextVersion {\n\t\t\treturn FmtUnknown\n\t\t}\n\t\treturn FmtText\n\t}\n\n\treturn FmtUnknown\n}\n\n// NewDecoder returns a new decoder based on the given input format.\n// If the input format does not imply otherwise, a text format decoder is returned.\nfunc NewDecoder(r io.Reader, format Format) Decoder {\n\tswitch format {\n\tcase FmtProtoDelim:\n\t\treturn &protoDecoder{r: r}\n\t}\n\treturn &textDecoder{r: r}\n}\n\n// protoDecoder implements the Decoder interface for protocol buffers.\ntype protoDecoder struct {\n\tr io.Reader\n}\n\n// Decode implements the Decoder interface.\nfunc (d *protoDecoder) Decode(v *dto.MetricFamily) error {\n\t_, err := pbutil.ReadDelimited(d.r, v)\n\tif err != nil {\n\t\treturn err\n\t}\n\tif !model.IsValidMetricName(model.LabelValue(v.GetName())) {\n\t\treturn fmt.Errorf(\"invalid metric name %q\", v.GetName())\n\t}\n\tfor _, m := range v.GetMetric() {\n\t\tif m == nil {\n\t\t\tcontinue\n\t\t}\n\t\tfor _, l := range m.GetLabel() {\n\t\t\tif l == nil {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif !model.LabelValue(l.GetValue()).IsValid() {\n\t\t\t\treturn fmt.Errorf(\"invalid label value %q\", l.GetValue())\n\t\t\t}\n\t\t\tif !model.LabelName(l.GetName()).IsValid() {\n\t\t\t\treturn fmt.Errorf(\"invalid label name %q\", l.GetName())\n\t\t\t}\n\t\t}\n\t}\n\treturn nil\n}\n\n// textDecoder implements the Decoder interface for the text protocol.\ntype textDecoder struct {\n\tr io.Reader\n\tp TextParser\n\tfams []*dto.MetricFamily\n}\n\n// Decode implements the Decoder interface.\nfunc (d *textDecoder) Decode(v *dto.MetricFamily) error {\n\t// TODO(fabxc): Wrap this as a line reader to make streaming safer.\n\tif len(d.fams) == 0 {\n\t\t// No cached metric families, read everything and parse metrics.\n\t\tfams, err := d.p.TextToMetricFamilies(d.r)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif len(fams) == 0 {\n\t\t\treturn io.EOF\n\t\t}\n\t\td.fams = make([]*dto.MetricFamily, 0, len(fams))\n\t\tfor _, f := range fams {\n\t\t\td.fams = append(d.fams, f)\n\t\t}\n\t}\n\n\t*v = *d.fams[0]\n\td.fams = d.fams[1:]\n\n\treturn nil\n}\n\n// SampleDecoder wraps a Decoder to extract samples from the metric families\n// decoded by the wrapped Decoder.\ntype SampleDecoder struct {\n\tDec Decoder\n\tOpts *DecodeOptions\n\n\tf dto.MetricFamily\n}\n\n// Decode calls the Decode method of the wrapped Decoder and then extracts the\n// samples from the decoded MetricFamily into the provided model.Vector.\nfunc (sd *SampleDecoder) Decode(s *model.Vector) error {\n\terr := sd.Dec.Decode(&sd.f)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s, err = extractSamples(&sd.f, sd.Opts)\n\treturn err\n}\n\n// ExtractSamples builds a slice of samples from the provided metric\n// families. If an error occurs during sample extraction, it continues to\n// extract from the remaining metric families. The returned error is the last\n// error that has occurred.\nfunc ExtractSamples(o *DecodeOptions, fams ...*dto.MetricFamily) (model.Vector, error) {\n\tvar (\n\t\tall model.Vector\n\t\tlastErr error\n\t)\n\tfor _, f := range fams {\n\t\tsome, err := extractSamples(f, o)\n\t\tif err != nil {\n\t\t\tlastErr = err\n\t\t\tcontinue\n\t\t}\n\t\tall = append(all, some...)\n\t}\n\treturn all, lastErr\n}\n\nfunc extractSamples(f *dto.MetricFamily, o *DecodeOptions) (model.Vector, error) {\n\tswitch f.GetType() {\n\tcase dto.MetricType_COUNTER:\n\t\treturn extractCounter(o, f), nil\n\tcase dto.MetricType_GAUGE:\n\t\treturn extractGauge(o, f), nil\n\tcase dto.MetricType_SUMMARY:\n\t\treturn extractSummary(o, f), nil\n\tcase dto.MetricType_UNTYPED:\n\t\treturn extractUntyped(o, f), nil\n\tcase dto.MetricType_HISTOGRAM:\n\t\treturn extractHistogram(o, f), nil\n\t}\n\treturn nil, fmt.Errorf(\"expfmt.extractSamples: unknown metric family type %v\", f.GetType())\n}\n\nfunc extractCounter(o *DecodeOptions, f *dto.MetricFamily) model.Vector {\n\tsamples := make(model.Vector, 0, len(f.Metric))\n\n\tfor _, m := range f.Metric {\n\t\tif m.Counter == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\tlset := make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName())\n\n\t\tsmpl := &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Counter.GetValue()),\n\t\t}\n\n\t\tif m.TimestampMs != nil {\n\t\t\tsmpl.Timestamp = model.TimeFromUnixNano(*m.TimestampMs * 1000000)\n\t\t} else {\n\t\t\tsmpl.Timestamp = o.Timestamp\n\t\t}\n\n\t\tsamples = append(samples, smpl)\n\t}\n\n\treturn samples\n}\n\nfunc extractGauge(o *DecodeOptions, f *dto.MetricFamily) model.Vector {\n\tsamples := make(model.Vector, 0, len(f.Metric))\n\n\tfor _, m := range f.Metric {\n\t\tif m.Gauge == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\tlset := make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName())\n\n\t\tsmpl := &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Gauge.GetValue()),\n\t\t}\n\n\t\tif m.TimestampMs != nil {\n\t\t\tsmpl.Timestamp = model.TimeFromUnixNano(*m.TimestampMs * 1000000)\n\t\t} else {\n\t\t\tsmpl.Timestamp = o.Timestamp\n\t\t}\n\n\t\tsamples = append(samples, smpl)\n\t}\n\n\treturn samples\n}\n\nfunc extractUntyped(o *DecodeOptions, f *dto.MetricFamily) model.Vector {\n\tsamples := make(model.Vector, 0, len(f.Metric))\n\n\tfor _, m := range f.Metric {\n\t\tif m.Untyped == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\tlset := make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName())\n\n\t\tsmpl := &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Untyped.GetValue()),\n\t\t}\n\n\t\tif m.TimestampMs != nil {\n\t\t\tsmpl.Timestamp = model.TimeFromUnixNano(*m.TimestampMs * 1000000)\n\t\t} else {\n\t\t\tsmpl.Timestamp = o.Timestamp\n\t\t}\n\n\t\tsamples = append(samples, smpl)\n\t}\n\n\treturn samples\n}\n\nfunc extractSummary(o *DecodeOptions, f *dto.MetricFamily) model.Vector {\n\tsamples := make(model.Vector, 0, len(f.Metric))\n\n\tfor _, m := range f.Metric {\n\t\tif m.Summary == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\ttimestamp := o.Timestamp\n\t\tif m.TimestampMs != nil {\n\t\t\ttimestamp = model.TimeFromUnixNano(*m.TimestampMs * 1000000)\n\t\t}\n\n\t\tfor _, q := range m.Summary.Quantile {\n\t\t\tlset := make(model.LabelSet, len(m.Label)+2)\n\t\t\tfor _, p := range m.Label {\n\t\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t\t}\n\t\t\t// BUG(matt): Update other names to \"quantile\".\n\t\t\tlset[model.LabelName(model.QuantileLabel)] = model.LabelValue(fmt.Sprint(q.GetQuantile()))\n\t\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName())\n\n\t\t\tsamples = append(samples, &model.Sample{\n\t\t\t\tMetric: model.Metric(lset),\n\t\t\t\tValue: model.SampleValue(q.GetValue()),\n\t\t\t\tTimestamp: timestamp,\n\t\t\t})\n\t\t}\n\n\t\tlset := make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_sum\")\n\n\t\tsamples = append(samples, &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Summary.GetSampleSum()),\n\t\t\tTimestamp: timestamp,\n\t\t})\n\n\t\tlset = make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_count\")\n\n\t\tsamples = append(samples, &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Summary.GetSampleCount()),\n\t\t\tTimestamp: timestamp,\n\t\t})\n\t}\n\n\treturn samples\n}\n\nfunc extractHistogram(o *DecodeOptions, f *dto.MetricFamily) model.Vector {\n\tsamples := make(model.Vector, 0, len(f.Metric))\n\n\tfor _, m := range f.Metric {\n\t\tif m.Histogram == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\ttimestamp := o.Timestamp\n\t\tif m.TimestampMs != nil {\n\t\t\ttimestamp = model.TimeFromUnixNano(*m.TimestampMs * 1000000)\n\t\t}\n\n\t\tinfSeen := false\n\n\t\tfor _, q := range m.Histogram.Bucket {\n\t\t\tlset := make(model.LabelSet, len(m.Label)+2)\n\t\t\tfor _, p := range m.Label {\n\t\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t\t}\n\t\t\tlset[model.LabelName(model.BucketLabel)] = model.LabelValue(fmt.Sprint(q.GetUpperBound()))\n\t\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_bucket\")\n\n\t\t\tif math.IsInf(q.GetUpperBound(), +1) {\n\t\t\t\tinfSeen = true\n\t\t\t}\n\n\t\t\tsamples = append(samples, &model.Sample{\n\t\t\t\tMetric: model.Metric(lset),\n\t\t\t\tValue: model.SampleValue(q.GetCumulativeCount()),\n\t\t\t\tTimestamp: timestamp,\n\t\t\t})\n\t\t}\n\n\t\tlset := make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_sum\")\n\n\t\tsamples = append(samples, &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Histogram.GetSampleSum()),\n\t\t\tTimestamp: timestamp,\n\t\t})\n\n\t\tlset = make(model.LabelSet, len(m.Label)+1)\n\t\tfor _, p := range m.Label {\n\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t}\n\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_count\")\n\n\t\tcount := &model.Sample{\n\t\t\tMetric: model.Metric(lset),\n\t\t\tValue: model.SampleValue(m.Histogram.GetSampleCount()),\n\t\t\tTimestamp: timestamp,\n\t\t}\n\t\tsamples = append(samples, count)\n\n\t\tif !infSeen {\n\t\t\t// Append an infinity bucket sample.\n\t\t\tlset := make(model.LabelSet, len(m.Label)+2)\n\t\t\tfor _, p := range m.Label {\n\t\t\t\tlset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())\n\t\t\t}\n\t\t\tlset[model.LabelName(model.BucketLabel)] = model.LabelValue(\"+Inf\")\n\t\t\tlset[model.MetricNameLabel] = model.LabelValue(f.GetName() + \"_bucket\")\n\n\t\t\tsamples = append(samples, &model.Sample{\n\t\t\t\tMetric: model.Metric(lset),\n\t\t\t\tValue: count.Value,\n\t\t\t\tTimestamp: timestamp,\n\t\t\t})\n\t\t}\n\t}\n\n\treturn samples\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/encode.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage expfmt\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\n\t\"github.com/golang/protobuf/proto\" //nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/matttproud/golang_protobuf_extensions/pbutil\"\n\t\"github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// Encoder types encode metric families into an underlying wire protocol.\ntype Encoder interface {\n\tEncode(*dto.MetricFamily) error\n}\n\n// Closer is implemented by Encoders that need to be closed to finalize\n// encoding. (For example, OpenMetrics needs a final `# EOF` line.)\n//\n// Note that all Encoder implementations returned from this package implement\n// Closer, too, even if the Close call is a no-op. This happens in preparation\n// for adding a Close method to the Encoder interface directly in a (mildly\n// breaking) release in the future.\ntype Closer interface {\n\tClose() error\n}\n\ntype encoderCloser struct {\n\tencode func(*dto.MetricFamily) error\n\tclose func() error\n}\n\nfunc (ec encoderCloser) Encode(v *dto.MetricFamily) error {\n\treturn ec.encode(v)\n}\n\nfunc (ec encoderCloser) Close() error {\n\treturn ec.close()\n}\n\n// Negotiate returns the Content-Type based on the given Accept header. If no\n// appropriate accepted type is found, FmtText is returned (which is the\n// Prometheus text format). This function will never negotiate FmtOpenMetrics,\n// as the support is still experimental. To include the option to negotiate\n// FmtOpenMetrics, use NegotiateOpenMetrics.\nfunc Negotiate(h http.Header) Format {\n\tfor _, ac := range goautoneg.ParseAccept(h.Get(hdrAccept)) {\n\t\tver := ac.Params[\"version\"]\n\t\tif ac.Type+\"/\"+ac.SubType == ProtoType && ac.Params[\"proto\"] == ProtoProtocol {\n\t\t\tswitch ac.Params[\"encoding\"] {\n\t\t\tcase \"delimited\":\n\t\t\t\treturn FmtProtoDelim\n\t\t\tcase \"text\":\n\t\t\t\treturn FmtProtoText\n\t\t\tcase \"compact-text\":\n\t\t\t\treturn FmtProtoCompact\n\t\t\t}\n\t\t}\n\t\tif ac.Type == \"text\" && ac.SubType == \"plain\" && (ver == TextVersion || ver == \"\") {\n\t\t\treturn FmtText\n\t\t}\n\t}\n\treturn FmtText\n}\n\n// NegotiateIncludingOpenMetrics works like Negotiate but includes\n// FmtOpenMetrics as an option for the result. Note that this function is\n// temporary and will disappear once FmtOpenMetrics is fully supported and as\n// such may be negotiated by the normal Negotiate function.\nfunc NegotiateIncludingOpenMetrics(h http.Header) Format {\n\tfor _, ac := range goautoneg.ParseAccept(h.Get(hdrAccept)) {\n\t\tver := ac.Params[\"version\"]\n\t\tif ac.Type+\"/\"+ac.SubType == ProtoType && ac.Params[\"proto\"] == ProtoProtocol {\n\t\t\tswitch ac.Params[\"encoding\"] {\n\t\t\tcase \"delimited\":\n\t\t\t\treturn FmtProtoDelim\n\t\t\tcase \"text\":\n\t\t\t\treturn FmtProtoText\n\t\t\tcase \"compact-text\":\n\t\t\t\treturn FmtProtoCompact\n\t\t\t}\n\t\t}\n\t\tif ac.Type == \"text\" && ac.SubType == \"plain\" && (ver == TextVersion || ver == \"\") {\n\t\t\treturn FmtText\n\t\t}\n\t\tif ac.Type+\"/\"+ac.SubType == OpenMetricsType && (ver == OpenMetricsVersion || ver == \"\") {\n\t\t\treturn FmtOpenMetrics\n\t\t}\n\t}\n\treturn FmtText\n}\n\n// NewEncoder returns a new encoder based on content type negotiation. All\n// Encoder implementations returned by NewEncoder also implement Closer, and\n// callers should always call the Close method. It is currently only required\n// for FmtOpenMetrics, but a future (breaking) release will add the Close method\n// to the Encoder interface directly. The current version of the Encoder\n// interface is kept for backwards compatibility.\nfunc NewEncoder(w io.Writer, format Format) Encoder {\n\tswitch format {\n\tcase FmtProtoDelim:\n\t\treturn encoderCloser{\n\t\t\tencode: func(v *dto.MetricFamily) error {\n\t\t\t\t_, err := pbutil.WriteDelimited(w, v)\n\t\t\t\treturn err\n\t\t\t},\n\t\t\tclose: func() error { return nil },\n\t\t}\n\tcase FmtProtoCompact:\n\t\treturn encoderCloser{\n\t\t\tencode: func(v *dto.MetricFamily) error {\n\t\t\t\t_, err := fmt.Fprintln(w, v.String())\n\t\t\t\treturn err\n\t\t\t},\n\t\t\tclose: func() error { return nil },\n\t\t}\n\tcase FmtProtoText:\n\t\treturn encoderCloser{\n\t\t\tencode: func(v *dto.MetricFamily) error {\n\t\t\t\t_, err := fmt.Fprintln(w, proto.MarshalTextString(v))\n\t\t\t\treturn err\n\t\t\t},\n\t\t\tclose: func() error { return nil },\n\t\t}\n\tcase FmtText:\n\t\treturn encoderCloser{\n\t\t\tencode: func(v *dto.MetricFamily) error {\n\t\t\t\t_, err := MetricFamilyToText(w, v)\n\t\t\t\treturn err\n\t\t\t},\n\t\t\tclose: func() error { return nil },\n\t\t}\n\tcase FmtOpenMetrics:\n\t\treturn encoderCloser{\n\t\t\tencode: func(v *dto.MetricFamily) error {\n\t\t\t\t_, err := MetricFamilyToOpenMetrics(w, v)\n\t\t\t\treturn err\n\t\t\t},\n\t\t\tclose: func() error {\n\t\t\t\t_, err := FinalizeOpenMetrics(w)\n\t\t\t\treturn err\n\t\t\t},\n\t\t}\n\t}\n\tpanic(fmt.Errorf(\"expfmt.NewEncoder: unknown format %q\", format))\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/expfmt.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package expfmt contains tools for reading and writing Prometheus metrics.\npackage expfmt\n\n// Format specifies the HTTP content type of the different wire protocols.\ntype Format string\n\n// Constants to assemble the Content-Type values for the different wire protocols.\nconst (\n\tTextVersion = \"0.0.4\"\n\tProtoType = `application/vnd.google.protobuf`\n\tProtoProtocol = `io.prometheus.client.MetricFamily`\n\tProtoFmt = ProtoType + \"; proto=\" + ProtoProtocol + \";\"\n\tOpenMetricsType = `application/openmetrics-text`\n\tOpenMetricsVersion = \"0.0.1\"\n\n\t// The Content-Type values for the different wire protocols.\n\tFmtUnknown Format = ``\n\tFmtText Format = `text/plain; version=` + TextVersion + `; charset=utf-8`\n\tFmtProtoDelim Format = ProtoFmt + ` encoding=delimited`\n\tFmtProtoText Format = ProtoFmt + ` encoding=text`\n\tFmtProtoCompact Format = ProtoFmt + ` encoding=compact-text`\n\tFmtOpenMetrics Format = OpenMetricsType + `; version=` + OpenMetricsVersion + `; charset=utf-8`\n)\n\nconst (\n\thdrContentType = \"Content-Type\"\n\thdrAccept = \"Accept\"\n)\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/fuzz.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Build only when actually fuzzing\n//go:build gofuzz\n// +build gofuzz\n\npackage expfmt\n\nimport \"bytes\"\n\n// Fuzz text metric parser with with github.com/dvyukov/go-fuzz:\n//\n// go-fuzz-build github.com/prometheus/common/expfmt\n// go-fuzz -bin expfmt-fuzz.zip -workdir fuzz\n//\n// Further input samples should go in the folder fuzz/corpus.\nfunc Fuzz(in []byte) int {\n\tparser := TextParser{}\n\t_, err := parser.TextToMetricFamilies(bytes.NewReader(in))\n\n\tif err != nil {\n\t\treturn 0\n\t}\n\n\treturn 1\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/openmetrics_create.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage expfmt\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/common/model\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// MetricFamilyToOpenMetrics converts a MetricFamily proto message into the\n// OpenMetrics text format and writes the resulting lines to 'out'. It returns\n// the number of bytes written and any error encountered. The output will have\n// the same order as the input, no further sorting is performed. Furthermore,\n// this function assumes the input is already sanitized and does not perform any\n// sanity checks. If the input contains duplicate metrics or invalid metric or\n// label names, the conversion will result in invalid text format output.\n//\n// This function fulfills the type 'expfmt.encoder'.\n//\n// Note that OpenMetrics requires a final `# EOF` line. Since this function acts\n// on individual metric families, it is the responsibility of the caller to\n// append this line to 'out' once all metric families have been written.\n// Conveniently, this can be done by calling FinalizeOpenMetrics.\n//\n// The output should be fully OpenMetrics compliant. However, there are a few\n// missing features and peculiarities to avoid complications when switching from\n// Prometheus to OpenMetrics or vice versa:\n//\n// - Counters are expected to have the `_total` suffix in their metric name. In\n// the output, the suffix will be truncated from the `# TYPE` and `# HELP`\n// line. A counter with a missing `_total` suffix is not an error. However,\n// its type will be set to `unknown` in that case to avoid invalid OpenMetrics\n// output.\n//\n// - No support for the following (optional) features: `# UNIT` line, `_created`\n// line, info type, stateset type, gaugehistogram type.\n//\n// - The size of exemplar labels is not checked (i.e. it's possible to create\n// exemplars that are larger than allowed by the OpenMetrics specification).\n//\n// - The value of Counters is not checked. (OpenMetrics doesn't allow counters\n// with a `NaN` value.)\nfunc MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily) (written int, err error) {\n\tname := in.GetName()\n\tif name == \"\" {\n\t\treturn 0, fmt.Errorf(\"MetricFamily has no name: %s\", in)\n\t}\n\n\t// Try the interface upgrade. If it doesn't work, we'll use a\n\t// bufio.Writer from the sync.Pool.\n\tw, ok := out.(enhancedWriter)\n\tif !ok {\n\t\tb := bufPool.Get().(*bufio.Writer)\n\t\tb.Reset(out)\n\t\tw = b\n\t\tdefer func() {\n\t\t\tbErr := b.Flush()\n\t\t\tif err == nil {\n\t\t\t\terr = bErr\n\t\t\t}\n\t\t\tbufPool.Put(b)\n\t\t}()\n\t}\n\n\tvar (\n\t\tn int\n\t\tmetricType = in.GetType()\n\t\tshortName = name\n\t)\n\tif metricType == dto.MetricType_COUNTER && strings.HasSuffix(shortName, \"_total\") {\n\t\tshortName = name[:len(name)-6]\n\t}\n\n\t// Comments, first HELP, then TYPE.\n\tif in.Help != nil {\n\t\tn, err = w.WriteString(\"# HELP \")\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\tn, err = w.WriteString(shortName)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\terr = w.WriteByte(' ')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\tn, err = writeEscapedString(w, *in.Help, true)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\terr = w.WriteByte('\\n')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\tn, err = w.WriteString(\"# TYPE \")\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\tn, err = w.WriteString(shortName)\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\tswitch metricType {\n\tcase dto.MetricType_COUNTER:\n\t\tif strings.HasSuffix(name, \"_total\") {\n\t\t\tn, err = w.WriteString(\" counter\\n\")\n\t\t} else {\n\t\t\tn, err = w.WriteString(\" unknown\\n\")\n\t\t}\n\tcase dto.MetricType_GAUGE:\n\t\tn, err = w.WriteString(\" gauge\\n\")\n\tcase dto.MetricType_SUMMARY:\n\t\tn, err = w.WriteString(\" summary\\n\")\n\tcase dto.MetricType_UNTYPED:\n\t\tn, err = w.WriteString(\" unknown\\n\")\n\tcase dto.MetricType_HISTOGRAM:\n\t\tn, err = w.WriteString(\" histogram\\n\")\n\tdefault:\n\t\treturn written, fmt.Errorf(\"unknown metric type %s\", metricType.String())\n\t}\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\n\t// Finally the samples, one line for each.\n\tfor _, metric := range in.Metric {\n\t\tswitch metricType {\n\t\tcase dto.MetricType_COUNTER:\n\t\t\tif metric.Counter == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected counter in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\t// Note that we have ensured above that either the name\n\t\t\t// ends on `_total` or that the rendered type is\n\t\t\t// `unknown`. Therefore, no `_total` must be added here.\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Counter.GetValue(), 0, false,\n\t\t\t\tmetric.Counter.Exemplar,\n\t\t\t)\n\t\tcase dto.MetricType_GAUGE:\n\t\t\tif metric.Gauge == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected gauge in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Gauge.GetValue(), 0, false,\n\t\t\t\tnil,\n\t\t\t)\n\t\tcase dto.MetricType_UNTYPED:\n\t\t\tif metric.Untyped == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected untyped in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Untyped.GetValue(), 0, false,\n\t\t\t\tnil,\n\t\t\t)\n\t\tcase dto.MetricType_SUMMARY:\n\t\t\tif metric.Summary == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected summary in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tfor _, q := range metric.Summary.Quantile {\n\t\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\t\tw, name, \"\", metric,\n\t\t\t\t\tmodel.QuantileLabel, q.GetQuantile(),\n\t\t\t\t\tq.GetValue(), 0, false,\n\t\t\t\t\tnil,\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"_sum\", metric, \"\", 0,\n\t\t\t\tmetric.Summary.GetSampleSum(), 0, false,\n\t\t\t\tnil,\n\t\t\t)\n\t\t\twritten += n\n\t\t\tif err != nil {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"_count\", metric, \"\", 0,\n\t\t\t\t0, metric.Summary.GetSampleCount(), true,\n\t\t\t\tnil,\n\t\t\t)\n\t\tcase dto.MetricType_HISTOGRAM:\n\t\t\tif metric.Histogram == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected histogram in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tinfSeen := false\n\t\t\tfor _, b := range metric.Histogram.Bucket {\n\t\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\t\tw, name, \"_bucket\", metric,\n\t\t\t\t\tmodel.BucketLabel, b.GetUpperBound(),\n\t\t\t\t\t0, b.GetCumulativeCount(), true,\n\t\t\t\t\tb.Exemplar,\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif math.IsInf(b.GetUpperBound(), +1) {\n\t\t\t\t\tinfSeen = true\n\t\t\t\t}\n\t\t\t}\n\t\t\tif !infSeen {\n\t\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\t\tw, name, \"_bucket\", metric,\n\t\t\t\t\tmodel.BucketLabel, math.Inf(+1),\n\t\t\t\t\t0, metric.Histogram.GetSampleCount(), true,\n\t\t\t\t\tnil,\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"_sum\", metric, \"\", 0,\n\t\t\t\tmetric.Histogram.GetSampleSum(), 0, false,\n\t\t\t\tnil,\n\t\t\t)\n\t\t\twritten += n\n\t\t\tif err != nil {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tn, err = writeOpenMetricsSample(\n\t\t\t\tw, name, \"_count\", metric, \"\", 0,\n\t\t\t\t0, metric.Histogram.GetSampleCount(), true,\n\t\t\t\tnil,\n\t\t\t)\n\t\tdefault:\n\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\"unexpected type in metric %s %s\", name, metric,\n\t\t\t)\n\t\t}\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\treturn\n}\n\n// FinalizeOpenMetrics writes the final `# EOF\\n` line required by OpenMetrics.\nfunc FinalizeOpenMetrics(w io.Writer) (written int, err error) {\n\treturn w.Write([]byte(\"# EOF\\n\"))\n}\n\n// writeOpenMetricsSample writes a single sample in OpenMetrics text format to\n// w, given the metric name, the metric proto message itself, optionally an\n// additional label name with a float64 value (use empty string as label name if\n// not required), the value (optionally as float64 or uint64, determined by\n// useIntValue), and optionally an exemplar (use nil if not required). The\n// function returns the number of bytes written and any error encountered.\nfunc writeOpenMetricsSample(\n\tw enhancedWriter,\n\tname, suffix string,\n\tmetric *dto.Metric,\n\tadditionalLabelName string, additionalLabelValue float64,\n\tfloatValue float64, intValue uint64, useIntValue bool,\n\texemplar *dto.Exemplar,\n) (int, error) {\n\tvar written int\n\tn, err := w.WriteString(name)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif suffix != \"\" {\n\t\tn, err = w.WriteString(suffix)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\tn, err = writeOpenMetricsLabelPairs(\n\t\tw, metric.Label, additionalLabelName, additionalLabelValue,\n\t)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\terr = w.WriteByte(' ')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif useIntValue {\n\t\tn, err = writeUint(w, intValue)\n\t} else {\n\t\tn, err = writeOpenMetricsFloat(w, floatValue)\n\t}\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif metric.TimestampMs != nil {\n\t\terr = w.WriteByte(' ')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\t// TODO(beorn7): Format this directly without converting to a float first.\n\t\tn, err = writeOpenMetricsFloat(w, float64(*metric.TimestampMs)/1000)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\tif exemplar != nil {\n\t\tn, err = writeExemplar(w, exemplar)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\terr = w.WriteByte('\\n')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\treturn written, nil\n}\n\n// writeOpenMetricsLabelPairs works like writeOpenMetrics but formats the float\n// in OpenMetrics style.\nfunc writeOpenMetricsLabelPairs(\n\tw enhancedWriter,\n\tin []*dto.LabelPair,\n\tadditionalLabelName string, additionalLabelValue float64,\n) (int, error) {\n\tif len(in) == 0 && additionalLabelName == \"\" {\n\t\treturn 0, nil\n\t}\n\tvar (\n\t\twritten int\n\t\tseparator byte = '{'\n\t)\n\tfor _, lp := range in {\n\t\terr := w.WriteByte(separator)\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err := w.WriteString(lp.GetName())\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = w.WriteString(`=\"`)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = writeEscapedString(w, lp.GetValue(), true)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\terr = w.WriteByte('\"')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tseparator = ','\n\t}\n\tif additionalLabelName != \"\" {\n\t\terr := w.WriteByte(separator)\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err := w.WriteString(additionalLabelName)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = w.WriteString(`=\"`)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = writeOpenMetricsFloat(w, additionalLabelValue)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\terr = w.WriteByte('\"')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\terr := w.WriteByte('}')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\treturn written, nil\n}\n\n// writeExemplar writes the provided exemplar in OpenMetrics format to w. The\n// function returns the number of bytes written and any error encountered.\nfunc writeExemplar(w enhancedWriter, e *dto.Exemplar) (int, error) {\n\twritten := 0\n\tn, err := w.WriteString(\" # \")\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tn, err = writeOpenMetricsLabelPairs(w, e.Label, \"\", 0)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\terr = w.WriteByte(' ')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tn, err = writeOpenMetricsFloat(w, e.GetValue())\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif e.Timestamp != nil {\n\t\terr = w.WriteByte(' ')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\terr = (*e).Timestamp.CheckValid()\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tts := (*e).Timestamp.AsTime()\n\t\t// TODO(beorn7): Format this directly from components of ts to\n\t\t// avoid overflow/underflow and precision issues of the float\n\t\t// conversion.\n\t\tn, err = writeOpenMetricsFloat(w, float64(ts.UnixNano())/1e9)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\treturn written, nil\n}\n\n// writeOpenMetricsFloat works like writeFloat but appends \".0\" if the resulting\n// number would otherwise contain neither a \".\" nor an \"e\".\nfunc writeOpenMetricsFloat(w enhancedWriter, f float64) (int, error) {\n\tswitch {\n\tcase f == 1:\n\t\treturn w.WriteString(\"1.0\")\n\tcase f == 0:\n\t\treturn w.WriteString(\"0.0\")\n\tcase f == -1:\n\t\treturn w.WriteString(\"-1.0\")\n\tcase math.IsNaN(f):\n\t\treturn w.WriteString(\"NaN\")\n\tcase math.IsInf(f, +1):\n\t\treturn w.WriteString(\"+Inf\")\n\tcase math.IsInf(f, -1):\n\t\treturn w.WriteString(\"-Inf\")\n\tdefault:\n\t\tbp := numBufPool.Get().(*[]byte)\n\t\t*bp = strconv.AppendFloat((*bp)[:0], f, 'g', -1, 64)\n\t\tif !bytes.ContainsAny(*bp, \"e.\") {\n\t\t\t*bp = append(*bp, '.', '0')\n\t\t}\n\t\twritten, err := w.Write(*bp)\n\t\tnumBufPool.Put(bp)\n\t\treturn written, err\n\t}\n}\n\n// writeUint is like writeInt just for uint64.\nfunc writeUint(w enhancedWriter, u uint64) (int, error) {\n\tbp := numBufPool.Get().(*[]byte)\n\t*bp = strconv.AppendUint((*bp)[:0], u, 10)\n\twritten, err := w.Write(*bp)\n\tnumBufPool.Put(bp)\n\treturn written, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/text_create.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage expfmt\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/ioutil\"\n\t\"math\"\n\t\"strconv\"\n\t\"strings\"\n\t\"sync\"\n\n\t\"github.com/prometheus/common/model\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n)\n\n// enhancedWriter has all the enhanced write functions needed here. bufio.Writer\n// implements it.\ntype enhancedWriter interface {\n\tio.Writer\n\tWriteRune(r rune) (n int, err error)\n\tWriteString(s string) (n int, err error)\n\tWriteByte(c byte) error\n}\n\nconst (\n\tinitialNumBufSize = 24\n)\n\nvar (\n\tbufPool = sync.Pool{\n\t\tNew: func() interface{} {\n\t\t\treturn bufio.NewWriter(ioutil.Discard)\n\t\t},\n\t}\n\tnumBufPool = sync.Pool{\n\t\tNew: func() interface{} {\n\t\t\tb := make([]byte, 0, initialNumBufSize)\n\t\t\treturn &b\n\t\t},\n\t}\n)\n\n// MetricFamilyToText converts a MetricFamily proto message into text format and\n// writes the resulting lines to 'out'. It returns the number of bytes written\n// and any error encountered. The output will have the same order as the input,\n// no further sorting is performed. Furthermore, this function assumes the input\n// is already sanitized and does not perform any sanity checks. If the input\n// contains duplicate metrics or invalid metric or label names, the conversion\n// will result in invalid text format output.\n//\n// This method fulfills the type 'prometheus.encoder'.\nfunc MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (written int, err error) {\n\t// Fail-fast checks.\n\tif len(in.Metric) == 0 {\n\t\treturn 0, fmt.Errorf(\"MetricFamily has no metrics: %s\", in)\n\t}\n\tname := in.GetName()\n\tif name == \"\" {\n\t\treturn 0, fmt.Errorf(\"MetricFamily has no name: %s\", in)\n\t}\n\n\t// Try the interface upgrade. If it doesn't work, we'll use a\n\t// bufio.Writer from the sync.Pool.\n\tw, ok := out.(enhancedWriter)\n\tif !ok {\n\t\tb := bufPool.Get().(*bufio.Writer)\n\t\tb.Reset(out)\n\t\tw = b\n\t\tdefer func() {\n\t\t\tbErr := b.Flush()\n\t\t\tif err == nil {\n\t\t\t\terr = bErr\n\t\t\t}\n\t\t\tbufPool.Put(b)\n\t\t}()\n\t}\n\n\tvar n int\n\n\t// Comments, first HELP, then TYPE.\n\tif in.Help != nil {\n\t\tn, err = w.WriteString(\"# HELP \")\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\tn, err = w.WriteString(name)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\terr = w.WriteByte(' ')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\tn, err = writeEscapedString(w, *in.Help, false)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\terr = w.WriteByte('\\n')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\tn, err = w.WriteString(\"# TYPE \")\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\tn, err = w.WriteString(name)\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\tmetricType := in.GetType()\n\tswitch metricType {\n\tcase dto.MetricType_COUNTER:\n\t\tn, err = w.WriteString(\" counter\\n\")\n\tcase dto.MetricType_GAUGE:\n\t\tn, err = w.WriteString(\" gauge\\n\")\n\tcase dto.MetricType_SUMMARY:\n\t\tn, err = w.WriteString(\" summary\\n\")\n\tcase dto.MetricType_UNTYPED:\n\t\tn, err = w.WriteString(\" untyped\\n\")\n\tcase dto.MetricType_HISTOGRAM:\n\t\tn, err = w.WriteString(\" histogram\\n\")\n\tdefault:\n\t\treturn written, fmt.Errorf(\"unknown metric type %s\", metricType.String())\n\t}\n\twritten += n\n\tif err != nil {\n\t\treturn\n\t}\n\n\t// Finally the samples, one line for each.\n\tfor _, metric := range in.Metric {\n\t\tswitch metricType {\n\t\tcase dto.MetricType_COUNTER:\n\t\t\tif metric.Counter == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected counter in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Counter.GetValue(),\n\t\t\t)\n\t\tcase dto.MetricType_GAUGE:\n\t\t\tif metric.Gauge == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected gauge in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Gauge.GetValue(),\n\t\t\t)\n\t\tcase dto.MetricType_UNTYPED:\n\t\t\tif metric.Untyped == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected untyped in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"\", metric, \"\", 0,\n\t\t\t\tmetric.Untyped.GetValue(),\n\t\t\t)\n\t\tcase dto.MetricType_SUMMARY:\n\t\t\tif metric.Summary == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected summary in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tfor _, q := range metric.Summary.Quantile {\n\t\t\t\tn, err = writeSample(\n\t\t\t\t\tw, name, \"\", metric,\n\t\t\t\t\tmodel.QuantileLabel, q.GetQuantile(),\n\t\t\t\t\tq.GetValue(),\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"_sum\", metric, \"\", 0,\n\t\t\t\tmetric.Summary.GetSampleSum(),\n\t\t\t)\n\t\t\twritten += n\n\t\t\tif err != nil {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"_count\", metric, \"\", 0,\n\t\t\t\tfloat64(metric.Summary.GetSampleCount()),\n\t\t\t)\n\t\tcase dto.MetricType_HISTOGRAM:\n\t\t\tif metric.Histogram == nil {\n\t\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\t\"expected histogram in metric %s %s\", name, metric,\n\t\t\t\t)\n\t\t\t}\n\t\t\tinfSeen := false\n\t\t\tfor _, b := range metric.Histogram.Bucket {\n\t\t\t\tn, err = writeSample(\n\t\t\t\t\tw, name, \"_bucket\", metric,\n\t\t\t\t\tmodel.BucketLabel, b.GetUpperBound(),\n\t\t\t\t\tfloat64(b.GetCumulativeCount()),\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif math.IsInf(b.GetUpperBound(), +1) {\n\t\t\t\t\tinfSeen = true\n\t\t\t\t}\n\t\t\t}\n\t\t\tif !infSeen {\n\t\t\t\tn, err = writeSample(\n\t\t\t\t\tw, name, \"_bucket\", metric,\n\t\t\t\t\tmodel.BucketLabel, math.Inf(+1),\n\t\t\t\t\tfloat64(metric.Histogram.GetSampleCount()),\n\t\t\t\t)\n\t\t\t\twritten += n\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"_sum\", metric, \"\", 0,\n\t\t\t\tmetric.Histogram.GetSampleSum(),\n\t\t\t)\n\t\t\twritten += n\n\t\t\tif err != nil {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tn, err = writeSample(\n\t\t\t\tw, name, \"_count\", metric, \"\", 0,\n\t\t\t\tfloat64(metric.Histogram.GetSampleCount()),\n\t\t\t)\n\t\tdefault:\n\t\t\treturn written, fmt.Errorf(\n\t\t\t\t\"unexpected type in metric %s %s\", name, metric,\n\t\t\t)\n\t\t}\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\treturn\n}\n\n// writeSample writes a single sample in text format to w, given the metric\n// name, the metric proto message itself, optionally an additional label name\n// with a float64 value (use empty string as label name if not required), and\n// the value. The function returns the number of bytes written and any error\n// encountered.\nfunc writeSample(\n\tw enhancedWriter,\n\tname, suffix string,\n\tmetric *dto.Metric,\n\tadditionalLabelName string, additionalLabelValue float64,\n\tvalue float64,\n) (int, error) {\n\tvar written int\n\tn, err := w.WriteString(name)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif suffix != \"\" {\n\t\tn, err = w.WriteString(suffix)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\tn, err = writeLabelPairs(\n\t\tw, metric.Label, additionalLabelName, additionalLabelValue,\n\t)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\terr = w.WriteByte(' ')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tn, err = writeFloat(w, value)\n\twritten += n\n\tif err != nil {\n\t\treturn written, err\n\t}\n\tif metric.TimestampMs != nil {\n\t\terr = w.WriteByte(' ')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = writeInt(w, *metric.TimestampMs)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\terr = w.WriteByte('\\n')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\treturn written, nil\n}\n\n// writeLabelPairs converts a slice of LabelPair proto messages plus the\n// explicitly given additional label pair into text formatted as required by the\n// text format and writes it to 'w'. An empty slice in combination with an empty\n// string 'additionalLabelName' results in nothing being written. Otherwise, the\n// label pairs are written, escaped as required by the text format, and enclosed\n// in '{...}'. The function returns the number of bytes written and any error\n// encountered.\nfunc writeLabelPairs(\n\tw enhancedWriter,\n\tin []*dto.LabelPair,\n\tadditionalLabelName string, additionalLabelValue float64,\n) (int, error) {\n\tif len(in) == 0 && additionalLabelName == \"\" {\n\t\treturn 0, nil\n\t}\n\tvar (\n\t\twritten int\n\t\tseparator byte = '{'\n\t)\n\tfor _, lp := range in {\n\t\terr := w.WriteByte(separator)\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err := w.WriteString(lp.GetName())\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = w.WriteString(`=\"`)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = writeEscapedString(w, lp.GetValue(), true)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\terr = w.WriteByte('\"')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tseparator = ','\n\t}\n\tif additionalLabelName != \"\" {\n\t\terr := w.WriteByte(separator)\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err := w.WriteString(additionalLabelName)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = w.WriteString(`=\"`)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\tn, err = writeFloat(w, additionalLabelValue)\n\t\twritten += n\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t\terr = w.WriteByte('\"')\n\t\twritten++\n\t\tif err != nil {\n\t\t\treturn written, err\n\t\t}\n\t}\n\terr := w.WriteByte('}')\n\twritten++\n\tif err != nil {\n\t\treturn written, err\n\t}\n\treturn written, nil\n}\n\n// writeEscapedString replaces '\\' by '\\\\', new line character by '\\n', and - if\n// includeDoubleQuote is true - '\"' by '\\\"'.\nvar (\n\tescaper = strings.NewReplacer(\"\\\\\", `\\\\`, \"\\n\", `\\n`)\n\tquotedEscaper = strings.NewReplacer(\"\\\\\", `\\\\`, \"\\n\", `\\n`, \"\\\"\", `\\\"`)\n)\n\nfunc writeEscapedString(w enhancedWriter, v string, includeDoubleQuote bool) (int, error) {\n\tif includeDoubleQuote {\n\t\treturn quotedEscaper.WriteString(w, v)\n\t}\n\treturn escaper.WriteString(w, v)\n}\n\n// writeFloat is equivalent to fmt.Fprint with a float64 argument but hardcodes\n// a few common cases for increased efficiency. For non-hardcoded cases, it uses\n// strconv.AppendFloat to avoid allocations, similar to writeInt.\nfunc writeFloat(w enhancedWriter, f float64) (int, error) {\n\tswitch {\n\tcase f == 1:\n\t\treturn 1, w.WriteByte('1')\n\tcase f == 0:\n\t\treturn 1, w.WriteByte('0')\n\tcase f == -1:\n\t\treturn w.WriteString(\"-1\")\n\tcase math.IsNaN(f):\n\t\treturn w.WriteString(\"NaN\")\n\tcase math.IsInf(f, +1):\n\t\treturn w.WriteString(\"+Inf\")\n\tcase math.IsInf(f, -1):\n\t\treturn w.WriteString(\"-Inf\")\n\tdefault:\n\t\tbp := numBufPool.Get().(*[]byte)\n\t\t*bp = strconv.AppendFloat((*bp)[:0], f, 'g', -1, 64)\n\t\twritten, err := w.Write(*bp)\n\t\tnumBufPool.Put(bp)\n\t\treturn written, err\n\t}\n}\n\n// writeInt is equivalent to fmt.Fprint with an int64 argument but uses\n// strconv.AppendInt with a byte slice taken from a sync.Pool to avoid\n// allocations.\nfunc writeInt(w enhancedWriter, i int64) (int, error) {\n\tbp := numBufPool.Get().(*[]byte)\n\t*bp = strconv.AppendInt((*bp)[:0], i, 10)\n\twritten, err := w.Write(*bp)\n\tnumBufPool.Put(bp)\n\treturn written, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/expfmt/text_parse.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage expfmt\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"strconv\"\n\t\"strings\"\n\n\tdto \"github.com/prometheus/client_model/go\"\n\n\t\"github.com/golang/protobuf/proto\" //nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.\n\t\"github.com/prometheus/common/model\"\n)\n\n// A stateFn is a function that represents a state in a state machine. By\n// executing it, the state is progressed to the next state. The stateFn returns\n// another stateFn, which represents the new state. The end state is represented\n// by nil.\ntype stateFn func() stateFn\n\n// ParseError signals errors while parsing the simple and flat text-based\n// exchange format.\ntype ParseError struct {\n\tLine int\n\tMsg string\n}\n\n// Error implements the error interface.\nfunc (e ParseError) Error() string {\n\treturn fmt.Sprintf(\"text format parsing error in line %d: %s\", e.Line, e.Msg)\n}\n\n// TextParser is used to parse the simple and flat text-based exchange format. Its\n// zero value is ready to use.\ntype TextParser struct {\n\tmetricFamiliesByName map[string]*dto.MetricFamily\n\tbuf *bufio.Reader // Where the parsed input is read through.\n\terr error // Most recent error.\n\tlineCount int // Tracks the line count for error messages.\n\tcurrentByte byte // The most recent byte read.\n\tcurrentToken bytes.Buffer // Re-used each time a token has to be gathered from multiple bytes.\n\tcurrentMF *dto.MetricFamily\n\tcurrentMetric *dto.Metric\n\tcurrentLabelPair *dto.LabelPair\n\n\t// The remaining member variables are only used for summaries/histograms.\n\tcurrentLabels map[string]string // All labels including '__name__' but excluding 'quantile'/'le'\n\t// Summary specific.\n\tsummaries map[uint64]*dto.Metric // Key is created with LabelsToSignature.\n\tcurrentQuantile float64\n\t// Histogram specific.\n\thistograms map[uint64]*dto.Metric // Key is created with LabelsToSignature.\n\tcurrentBucket float64\n\t// These tell us if the currently processed line ends on '_count' or\n\t// '_sum' respectively and belong to a summary/histogram, representing the sample\n\t// count and sum of that summary/histogram.\n\tcurrentIsSummaryCount, currentIsSummarySum bool\n\tcurrentIsHistogramCount, currentIsHistogramSum bool\n}\n\n// TextToMetricFamilies reads 'in' as the simple and flat text-based exchange\n// format and creates MetricFamily proto messages. It returns the MetricFamily\n// proto messages in a map where the metric names are the keys, along with any\n// error encountered.\n//\n// If the input contains duplicate metrics (i.e. lines with the same metric name\n// and exactly the same label set), the resulting MetricFamily will contain\n// duplicate Metric proto messages. Similar is true for duplicate label\n// names. Checks for duplicates have to be performed separately, if required.\n// Also note that neither the metrics within each MetricFamily are sorted nor\n// the label pairs within each Metric. Sorting is not required for the most\n// frequent use of this method, which is sample ingestion in the Prometheus\n// server. However, for presentation purposes, you might want to sort the\n// metrics, and in some cases, you must sort the labels, e.g. for consumption by\n// the metric family injection hook of the Prometheus registry.\n//\n// Summaries and histograms are rather special beasts. You would probably not\n// use them in the simple text format anyway. This method can deal with\n// summaries and histograms if they are presented in exactly the way the\n// text.Create function creates them.\n//\n// This method must not be called concurrently. If you want to parse different\n// input concurrently, instantiate a separate Parser for each goroutine.\nfunc (p *TextParser) TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricFamily, error) {\n\tp.reset(in)\n\tfor nextState := p.startOfLine; nextState != nil; nextState = nextState() {\n\t\t// Magic happens here...\n\t}\n\t// Get rid of empty metric families.\n\tfor k, mf := range p.metricFamiliesByName {\n\t\tif len(mf.GetMetric()) == 0 {\n\t\t\tdelete(p.metricFamiliesByName, k)\n\t\t}\n\t}\n\t// If p.err is io.EOF now, we have run into a premature end of the input\n\t// stream. Turn this error into something nicer and more\n\t// meaningful. (io.EOF is often used as a signal for the legitimate end\n\t// of an input stream.)\n\tif p.err == io.EOF {\n\t\tp.parseError(\"unexpected end of input stream\")\n\t}\n\treturn p.metricFamiliesByName, p.err\n}\n\nfunc (p *TextParser) reset(in io.Reader) {\n\tp.metricFamiliesByName = map[string]*dto.MetricFamily{}\n\tif p.buf == nil {\n\t\tp.buf = bufio.NewReader(in)\n\t} else {\n\t\tp.buf.Reset(in)\n\t}\n\tp.err = nil\n\tp.lineCount = 0\n\tif p.summaries == nil || len(p.summaries) > 0 {\n\t\tp.summaries = map[uint64]*dto.Metric{}\n\t}\n\tif p.histograms == nil || len(p.histograms) > 0 {\n\t\tp.histograms = map[uint64]*dto.Metric{}\n\t}\n\tp.currentQuantile = math.NaN()\n\tp.currentBucket = math.NaN()\n}\n\n// startOfLine represents the state where the next byte read from p.buf is the\n// start of a line (or whitespace leading up to it).\nfunc (p *TextParser) startOfLine() stateFn {\n\tp.lineCount++\n\tif p.skipBlankTab(); p.err != nil {\n\t\t// End of input reached. This is the only case where\n\t\t// that is not an error but a signal that we are done.\n\t\tp.err = nil\n\t\treturn nil\n\t}\n\tswitch p.currentByte {\n\tcase '#':\n\t\treturn p.startComment\n\tcase '\\n':\n\t\treturn p.startOfLine // Empty line, start the next one.\n\t}\n\treturn p.readingMetricName\n}\n\n// startComment represents the state where the next byte read from p.buf is the\n// start of a comment (or whitespace leading up to it).\nfunc (p *TextParser) startComment() stateFn {\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte == '\\n' {\n\t\treturn p.startOfLine\n\t}\n\tif p.readTokenUntilWhitespace(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\t// If we have hit the end of line already, there is nothing left\n\t// to do. This is not considered a syntax error.\n\tif p.currentByte == '\\n' {\n\t\treturn p.startOfLine\n\t}\n\tkeyword := p.currentToken.String()\n\tif keyword != \"HELP\" && keyword != \"TYPE\" {\n\t\t// Generic comment, ignore by fast forwarding to end of line.\n\t\tfor p.currentByte != '\\n' {\n\t\t\tif p.currentByte, p.err = p.buf.ReadByte(); p.err != nil {\n\t\t\t\treturn nil // Unexpected end of input.\n\t\t\t}\n\t\t}\n\t\treturn p.startOfLine\n\t}\n\t// There is something. Next has to be a metric name.\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.readTokenAsMetricName(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte == '\\n' {\n\t\t// At the end of the line already.\n\t\t// Again, this is not considered a syntax error.\n\t\treturn p.startOfLine\n\t}\n\tif !isBlankOrTab(p.currentByte) {\n\t\tp.parseError(\"invalid metric name in comment\")\n\t\treturn nil\n\t}\n\tp.setOrCreateCurrentMF()\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte == '\\n' {\n\t\t// At the end of the line already.\n\t\t// Again, this is not considered a syntax error.\n\t\treturn p.startOfLine\n\t}\n\tswitch keyword {\n\tcase \"HELP\":\n\t\treturn p.readingHelp\n\tcase \"TYPE\":\n\t\treturn p.readingType\n\t}\n\tpanic(fmt.Sprintf(\"code error: unexpected keyword %q\", keyword))\n}\n\n// readingMetricName represents the state where the last byte read (now in\n// p.currentByte) is the first byte of a metric name.\nfunc (p *TextParser) readingMetricName() stateFn {\n\tif p.readTokenAsMetricName(); p.err != nil {\n\t\treturn nil\n\t}\n\tif p.currentToken.Len() == 0 {\n\t\tp.parseError(\"invalid metric name\")\n\t\treturn nil\n\t}\n\tp.setOrCreateCurrentMF()\n\t// Now is the time to fix the type if it hasn't happened yet.\n\tif p.currentMF.Type == nil {\n\t\tp.currentMF.Type = dto.MetricType_UNTYPED.Enum()\n\t}\n\tp.currentMetric = &dto.Metric{}\n\t// Do not append the newly created currentMetric to\n\t// currentMF.Metric right now. First wait if this is a summary,\n\t// and the metric exists already, which we can only know after\n\t// having read all the labels.\n\tif p.skipBlankTabIfCurrentBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\treturn p.readingLabels\n}\n\n// readingLabels represents the state where the last byte read (now in\n// p.currentByte) is either the first byte of the label set (i.e. a '{'), or the\n// first byte of the value (otherwise).\nfunc (p *TextParser) readingLabels() stateFn {\n\t// Summaries/histograms are special. We have to reset the\n\t// currentLabels map, currentQuantile and currentBucket before starting to\n\t// read labels.\n\tif p.currentMF.GetType() == dto.MetricType_SUMMARY || p.currentMF.GetType() == dto.MetricType_HISTOGRAM {\n\t\tp.currentLabels = map[string]string{}\n\t\tp.currentLabels[string(model.MetricNameLabel)] = p.currentMF.GetName()\n\t\tp.currentQuantile = math.NaN()\n\t\tp.currentBucket = math.NaN()\n\t}\n\tif p.currentByte != '{' {\n\t\treturn p.readingValue\n\t}\n\treturn p.startLabelName\n}\n\n// startLabelName represents the state where the next byte read from p.buf is\n// the start of a label name (or whitespace leading up to it).\nfunc (p *TextParser) startLabelName() stateFn {\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte == '}' {\n\t\tif p.skipBlankTab(); p.err != nil {\n\t\t\treturn nil // Unexpected end of input.\n\t\t}\n\t\treturn p.readingValue\n\t}\n\tif p.readTokenAsLabelName(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentToken.Len() == 0 {\n\t\tp.parseError(fmt.Sprintf(\"invalid label name for metric %q\", p.currentMF.GetName()))\n\t\treturn nil\n\t}\n\tp.currentLabelPair = &dto.LabelPair{Name: proto.String(p.currentToken.String())}\n\tif p.currentLabelPair.GetName() == string(model.MetricNameLabel) {\n\t\tp.parseError(fmt.Sprintf(\"label name %q is reserved\", model.MetricNameLabel))\n\t\treturn nil\n\t}\n\t// Special summary/histogram treatment. Don't add 'quantile' and 'le'\n\t// labels to 'real' labels.\n\tif !(p.currentMF.GetType() == dto.MetricType_SUMMARY && p.currentLabelPair.GetName() == model.QuantileLabel) &&\n\t\t!(p.currentMF.GetType() == dto.MetricType_HISTOGRAM && p.currentLabelPair.GetName() == model.BucketLabel) {\n\t\tp.currentMetric.Label = append(p.currentMetric.Label, p.currentLabelPair)\n\t}\n\tif p.skipBlankTabIfCurrentBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte != '=' {\n\t\tp.parseError(fmt.Sprintf(\"expected '=' after label name, found %q\", p.currentByte))\n\t\treturn nil\n\t}\n\t// Check for duplicate label names.\n\tlabels := make(map[string]struct{})\n\tfor _, l := range p.currentMetric.Label {\n\t\tlName := l.GetName()\n\t\tif _, exists := labels[lName]; !exists {\n\t\t\tlabels[lName] = struct{}{}\n\t\t} else {\n\t\t\tp.parseError(fmt.Sprintf(\"duplicate label names for metric %q\", p.currentMF.GetName()))\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn p.startLabelValue\n}\n\n// startLabelValue represents the state where the next byte read from p.buf is\n// the start of a (quoted) label value (or whitespace leading up to it).\nfunc (p *TextParser) startLabelValue() stateFn {\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentByte != '\"' {\n\t\tp.parseError(fmt.Sprintf(\"expected '\\\"' at start of label value, found %q\", p.currentByte))\n\t\treturn nil\n\t}\n\tif p.readTokenAsLabelValue(); p.err != nil {\n\t\treturn nil\n\t}\n\tif !model.LabelValue(p.currentToken.String()).IsValid() {\n\t\tp.parseError(fmt.Sprintf(\"invalid label value %q\", p.currentToken.String()))\n\t\treturn nil\n\t}\n\tp.currentLabelPair.Value = proto.String(p.currentToken.String())\n\t// Special treatment of summaries:\n\t// - Quantile labels are special, will result in dto.Quantile later.\n\t// - Other labels have to be added to currentLabels for signature calculation.\n\tif p.currentMF.GetType() == dto.MetricType_SUMMARY {\n\t\tif p.currentLabelPair.GetName() == model.QuantileLabel {\n\t\t\tif p.currentQuantile, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil {\n\t\t\t\t// Create a more helpful error message.\n\t\t\t\tp.parseError(fmt.Sprintf(\"expected float as value for 'quantile' label, got %q\", p.currentLabelPair.GetValue()))\n\t\t\t\treturn nil\n\t\t\t}\n\t\t} else {\n\t\t\tp.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue()\n\t\t}\n\t}\n\t// Similar special treatment of histograms.\n\tif p.currentMF.GetType() == dto.MetricType_HISTOGRAM {\n\t\tif p.currentLabelPair.GetName() == model.BucketLabel {\n\t\t\tif p.currentBucket, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil {\n\t\t\t\t// Create a more helpful error message.\n\t\t\t\tp.parseError(fmt.Sprintf(\"expected float as value for 'le' label, got %q\", p.currentLabelPair.GetValue()))\n\t\t\t\treturn nil\n\t\t\t}\n\t\t} else {\n\t\t\tp.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue()\n\t\t}\n\t}\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tswitch p.currentByte {\n\tcase ',':\n\t\treturn p.startLabelName\n\n\tcase '}':\n\t\tif p.skipBlankTab(); p.err != nil {\n\t\t\treturn nil // Unexpected end of input.\n\t\t}\n\t\treturn p.readingValue\n\tdefault:\n\t\tp.parseError(fmt.Sprintf(\"unexpected end of label value %q\", p.currentLabelPair.GetValue()))\n\t\treturn nil\n\t}\n}\n\n// readingValue represents the state where the last byte read (now in\n// p.currentByte) is the first byte of the sample value (i.e. a float).\nfunc (p *TextParser) readingValue() stateFn {\n\t// When we are here, we have read all the labels, so for the\n\t// special case of a summary/histogram, we can finally find out\n\t// if the metric already exists.\n\tif p.currentMF.GetType() == dto.MetricType_SUMMARY {\n\t\tsignature := model.LabelsToSignature(p.currentLabels)\n\t\tif summary := p.summaries[signature]; summary != nil {\n\t\t\tp.currentMetric = summary\n\t\t} else {\n\t\t\tp.summaries[signature] = p.currentMetric\n\t\t\tp.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)\n\t\t}\n\t} else if p.currentMF.GetType() == dto.MetricType_HISTOGRAM {\n\t\tsignature := model.LabelsToSignature(p.currentLabels)\n\t\tif histogram := p.histograms[signature]; histogram != nil {\n\t\t\tp.currentMetric = histogram\n\t\t} else {\n\t\t\tp.histograms[signature] = p.currentMetric\n\t\t\tp.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)\n\t\t}\n\t} else {\n\t\tp.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)\n\t}\n\tif p.readTokenUntilWhitespace(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tvalue, err := parseFloat(p.currentToken.String())\n\tif err != nil {\n\t\t// Create a more helpful error message.\n\t\tp.parseError(fmt.Sprintf(\"expected float as value, got %q\", p.currentToken.String()))\n\t\treturn nil\n\t}\n\tswitch p.currentMF.GetType() {\n\tcase dto.MetricType_COUNTER:\n\t\tp.currentMetric.Counter = &dto.Counter{Value: proto.Float64(value)}\n\tcase dto.MetricType_GAUGE:\n\t\tp.currentMetric.Gauge = &dto.Gauge{Value: proto.Float64(value)}\n\tcase dto.MetricType_UNTYPED:\n\t\tp.currentMetric.Untyped = &dto.Untyped{Value: proto.Float64(value)}\n\tcase dto.MetricType_SUMMARY:\n\t\t// *sigh*\n\t\tif p.currentMetric.Summary == nil {\n\t\t\tp.currentMetric.Summary = &dto.Summary{}\n\t\t}\n\t\tswitch {\n\t\tcase p.currentIsSummaryCount:\n\t\t\tp.currentMetric.Summary.SampleCount = proto.Uint64(uint64(value))\n\t\tcase p.currentIsSummarySum:\n\t\t\tp.currentMetric.Summary.SampleSum = proto.Float64(value)\n\t\tcase !math.IsNaN(p.currentQuantile):\n\t\t\tp.currentMetric.Summary.Quantile = append(\n\t\t\t\tp.currentMetric.Summary.Quantile,\n\t\t\t\t&dto.Quantile{\n\t\t\t\t\tQuantile: proto.Float64(p.currentQuantile),\n\t\t\t\t\tValue: proto.Float64(value),\n\t\t\t\t},\n\t\t\t)\n\t\t}\n\tcase dto.MetricType_HISTOGRAM:\n\t\t// *sigh*\n\t\tif p.currentMetric.Histogram == nil {\n\t\t\tp.currentMetric.Histogram = &dto.Histogram{}\n\t\t}\n\t\tswitch {\n\t\tcase p.currentIsHistogramCount:\n\t\t\tp.currentMetric.Histogram.SampleCount = proto.Uint64(uint64(value))\n\t\tcase p.currentIsHistogramSum:\n\t\t\tp.currentMetric.Histogram.SampleSum = proto.Float64(value)\n\t\tcase !math.IsNaN(p.currentBucket):\n\t\t\tp.currentMetric.Histogram.Bucket = append(\n\t\t\t\tp.currentMetric.Histogram.Bucket,\n\t\t\t\t&dto.Bucket{\n\t\t\t\t\tUpperBound: proto.Float64(p.currentBucket),\n\t\t\t\t\tCumulativeCount: proto.Uint64(uint64(value)),\n\t\t\t\t},\n\t\t\t)\n\t\t}\n\tdefault:\n\t\tp.err = fmt.Errorf(\"unexpected type for metric name %q\", p.currentMF.GetName())\n\t}\n\tif p.currentByte == '\\n' {\n\t\treturn p.startOfLine\n\t}\n\treturn p.startTimestamp\n}\n\n// startTimestamp represents the state where the next byte read from p.buf is\n// the start of the timestamp (or whitespace leading up to it).\nfunc (p *TextParser) startTimestamp() stateFn {\n\tif p.skipBlankTab(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.readTokenUntilWhitespace(); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\ttimestamp, err := strconv.ParseInt(p.currentToken.String(), 10, 64)\n\tif err != nil {\n\t\t// Create a more helpful error message.\n\t\tp.parseError(fmt.Sprintf(\"expected integer as timestamp, got %q\", p.currentToken.String()))\n\t\treturn nil\n\t}\n\tp.currentMetric.TimestampMs = proto.Int64(timestamp)\n\tif p.readTokenUntilNewline(false); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tif p.currentToken.Len() > 0 {\n\t\tp.parseError(fmt.Sprintf(\"spurious string after timestamp: %q\", p.currentToken.String()))\n\t\treturn nil\n\t}\n\treturn p.startOfLine\n}\n\n// readingHelp represents the state where the last byte read (now in\n// p.currentByte) is the first byte of the docstring after 'HELP'.\nfunc (p *TextParser) readingHelp() stateFn {\n\tif p.currentMF.Help != nil {\n\t\tp.parseError(fmt.Sprintf(\"second HELP line for metric name %q\", p.currentMF.GetName()))\n\t\treturn nil\n\t}\n\t// Rest of line is the docstring.\n\tif p.readTokenUntilNewline(true); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tp.currentMF.Help = proto.String(p.currentToken.String())\n\treturn p.startOfLine\n}\n\n// readingType represents the state where the last byte read (now in\n// p.currentByte) is the first byte of the type hint after 'HELP'.\nfunc (p *TextParser) readingType() stateFn {\n\tif p.currentMF.Type != nil {\n\t\tp.parseError(fmt.Sprintf(\"second TYPE line for metric name %q, or TYPE reported after samples\", p.currentMF.GetName()))\n\t\treturn nil\n\t}\n\t// Rest of line is the type.\n\tif p.readTokenUntilNewline(false); p.err != nil {\n\t\treturn nil // Unexpected end of input.\n\t}\n\tmetricType, ok := dto.MetricType_value[strings.ToUpper(p.currentToken.String())]\n\tif !ok {\n\t\tp.parseError(fmt.Sprintf(\"unknown metric type %q\", p.currentToken.String()))\n\t\treturn nil\n\t}\n\tp.currentMF.Type = dto.MetricType(metricType).Enum()\n\treturn p.startOfLine\n}\n\n// parseError sets p.err to a ParseError at the current line with the given\n// message.\nfunc (p *TextParser) parseError(msg string) {\n\tp.err = ParseError{\n\t\tLine: p.lineCount,\n\t\tMsg: msg,\n\t}\n}\n\n// skipBlankTab reads (and discards) bytes from p.buf until it encounters a byte\n// that is neither ' ' nor '\\t'. That byte is left in p.currentByte.\nfunc (p *TextParser) skipBlankTab() {\n\tfor {\n\t\tif p.currentByte, p.err = p.buf.ReadByte(); p.err != nil || !isBlankOrTab(p.currentByte) {\n\t\t\treturn\n\t\t}\n\t}\n}\n\n// skipBlankTabIfCurrentBlankTab works exactly as skipBlankTab but doesn't do\n// anything if p.currentByte is neither ' ' nor '\\t'.\nfunc (p *TextParser) skipBlankTabIfCurrentBlankTab() {\n\tif isBlankOrTab(p.currentByte) {\n\t\tp.skipBlankTab()\n\t}\n}\n\n// readTokenUntilWhitespace copies bytes from p.buf into p.currentToken. The\n// first byte considered is the byte already read (now in p.currentByte). The\n// first whitespace byte encountered is still copied into p.currentByte, but not\n// into p.currentToken.\nfunc (p *TextParser) readTokenUntilWhitespace() {\n\tp.currentToken.Reset()\n\tfor p.err == nil && !isBlankOrTab(p.currentByte) && p.currentByte != '\\n' {\n\t\tp.currentToken.WriteByte(p.currentByte)\n\t\tp.currentByte, p.err = p.buf.ReadByte()\n\t}\n}\n\n// readTokenUntilNewline copies bytes from p.buf into p.currentToken. The first\n// byte considered is the byte already read (now in p.currentByte). The first\n// newline byte encountered is still copied into p.currentByte, but not into\n// p.currentToken. If recognizeEscapeSequence is true, two escape sequences are\n// recognized: '\\\\' translates into '\\', and '\\n' into a line-feed character.\n// All other escape sequences are invalid and cause an error.\nfunc (p *TextParser) readTokenUntilNewline(recognizeEscapeSequence bool) {\n\tp.currentToken.Reset()\n\tescaped := false\n\tfor p.err == nil {\n\t\tif recognizeEscapeSequence && escaped {\n\t\t\tswitch p.currentByte {\n\t\t\tcase '\\\\':\n\t\t\t\tp.currentToken.WriteByte(p.currentByte)\n\t\t\tcase 'n':\n\t\t\t\tp.currentToken.WriteByte('\\n')\n\t\t\tdefault:\n\t\t\t\tp.parseError(fmt.Sprintf(\"invalid escape sequence '\\\\%c'\", p.currentByte))\n\t\t\t\treturn\n\t\t\t}\n\t\t\tescaped = false\n\t\t} else {\n\t\t\tswitch p.currentByte {\n\t\t\tcase '\\n':\n\t\t\t\treturn\n\t\t\tcase '\\\\':\n\t\t\t\tescaped = true\n\t\t\tdefault:\n\t\t\t\tp.currentToken.WriteByte(p.currentByte)\n\t\t\t}\n\t\t}\n\t\tp.currentByte, p.err = p.buf.ReadByte()\n\t}\n}\n\n// readTokenAsMetricName copies a metric name from p.buf into p.currentToken.\n// The first byte considered is the byte already read (now in p.currentByte).\n// The first byte not part of a metric name is still copied into p.currentByte,\n// but not into p.currentToken.\nfunc (p *TextParser) readTokenAsMetricName() {\n\tp.currentToken.Reset()\n\tif !isValidMetricNameStart(p.currentByte) {\n\t\treturn\n\t}\n\tfor {\n\t\tp.currentToken.WriteByte(p.currentByte)\n\t\tp.currentByte, p.err = p.buf.ReadByte()\n\t\tif p.err != nil || !isValidMetricNameContinuation(p.currentByte) {\n\t\t\treturn\n\t\t}\n\t}\n}\n\n// readTokenAsLabelName copies a label name from p.buf into p.currentToken.\n// The first byte considered is the byte already read (now in p.currentByte).\n// The first byte not part of a label name is still copied into p.currentByte,\n// but not into p.currentToken.\nfunc (p *TextParser) readTokenAsLabelName() {\n\tp.currentToken.Reset()\n\tif !isValidLabelNameStart(p.currentByte) {\n\t\treturn\n\t}\n\tfor {\n\t\tp.currentToken.WriteByte(p.currentByte)\n\t\tp.currentByte, p.err = p.buf.ReadByte()\n\t\tif p.err != nil || !isValidLabelNameContinuation(p.currentByte) {\n\t\t\treturn\n\t\t}\n\t}\n}\n\n// readTokenAsLabelValue copies a label value from p.buf into p.currentToken.\n// In contrast to the other 'readTokenAs...' functions, which start with the\n// last read byte in p.currentByte, this method ignores p.currentByte and starts\n// with reading a new byte from p.buf. The first byte not part of a label value\n// is still copied into p.currentByte, but not into p.currentToken.\nfunc (p *TextParser) readTokenAsLabelValue() {\n\tp.currentToken.Reset()\n\tescaped := false\n\tfor {\n\t\tif p.currentByte, p.err = p.buf.ReadByte(); p.err != nil {\n\t\t\treturn\n\t\t}\n\t\tif escaped {\n\t\t\tswitch p.currentByte {\n\t\t\tcase '\"', '\\\\':\n\t\t\t\tp.currentToken.WriteByte(p.currentByte)\n\t\t\tcase 'n':\n\t\t\t\tp.currentToken.WriteByte('\\n')\n\t\t\tdefault:\n\t\t\t\tp.parseError(fmt.Sprintf(\"invalid escape sequence '\\\\%c'\", p.currentByte))\n\t\t\t\treturn\n\t\t\t}\n\t\t\tescaped = false\n\t\t\tcontinue\n\t\t}\n\t\tswitch p.currentByte {\n\t\tcase '\"':\n\t\t\treturn\n\t\tcase '\\n':\n\t\t\tp.parseError(fmt.Sprintf(\"label value %q contains unescaped new-line\", p.currentToken.String()))\n\t\t\treturn\n\t\tcase '\\\\':\n\t\t\tescaped = true\n\t\tdefault:\n\t\t\tp.currentToken.WriteByte(p.currentByte)\n\t\t}\n\t}\n}\n\nfunc (p *TextParser) setOrCreateCurrentMF() {\n\tp.currentIsSummaryCount = false\n\tp.currentIsSummarySum = false\n\tp.currentIsHistogramCount = false\n\tp.currentIsHistogramSum = false\n\tname := p.currentToken.String()\n\tif p.currentMF = p.metricFamiliesByName[name]; p.currentMF != nil {\n\t\treturn\n\t}\n\t// Try out if this is a _sum or _count for a summary/histogram.\n\tsummaryName := summaryMetricName(name)\n\tif p.currentMF = p.metricFamiliesByName[summaryName]; p.currentMF != nil {\n\t\tif p.currentMF.GetType() == dto.MetricType_SUMMARY {\n\t\t\tif isCount(name) {\n\t\t\t\tp.currentIsSummaryCount = true\n\t\t\t}\n\t\t\tif isSum(name) {\n\t\t\t\tp.currentIsSummarySum = true\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t}\n\thistogramName := histogramMetricName(name)\n\tif p.currentMF = p.metricFamiliesByName[histogramName]; p.currentMF != nil {\n\t\tif p.currentMF.GetType() == dto.MetricType_HISTOGRAM {\n\t\t\tif isCount(name) {\n\t\t\t\tp.currentIsHistogramCount = true\n\t\t\t}\n\t\t\tif isSum(name) {\n\t\t\t\tp.currentIsHistogramSum = true\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t}\n\tp.currentMF = &dto.MetricFamily{Name: proto.String(name)}\n\tp.metricFamiliesByName[name] = p.currentMF\n}\n\nfunc isValidLabelNameStart(b byte) bool {\n\treturn (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_'\n}\n\nfunc isValidLabelNameContinuation(b byte) bool {\n\treturn isValidLabelNameStart(b) || (b >= '0' && b <= '9')\n}\n\nfunc isValidMetricNameStart(b byte) bool {\n\treturn isValidLabelNameStart(b) || b == ':'\n}\n\nfunc isValidMetricNameContinuation(b byte) bool {\n\treturn isValidLabelNameContinuation(b) || b == ':'\n}\n\nfunc isBlankOrTab(b byte) bool {\n\treturn b == ' ' || b == '\\t'\n}\n\nfunc isCount(name string) bool {\n\treturn len(name) > 6 && name[len(name)-6:] == \"_count\"\n}\n\nfunc isSum(name string) bool {\n\treturn len(name) > 4 && name[len(name)-4:] == \"_sum\"\n}\n\nfunc isBucket(name string) bool {\n\treturn len(name) > 7 && name[len(name)-7:] == \"_bucket\"\n}\n\nfunc summaryMetricName(name string) string {\n\tswitch {\n\tcase isCount(name):\n\t\treturn name[:len(name)-6]\n\tcase isSum(name):\n\t\treturn name[:len(name)-4]\n\tdefault:\n\t\treturn name\n\t}\n}\n\nfunc histogramMetricName(name string) string {\n\tswitch {\n\tcase isCount(name):\n\t\treturn name[:len(name)-6]\n\tcase isSum(name):\n\t\treturn name[:len(name)-4]\n\tcase isBucket(name):\n\t\treturn name[:len(name)-7]\n\tdefault:\n\t\treturn name\n\t}\n}\n\nfunc parseFloat(s string) (float64, error) {\n\tif strings.ContainsAny(s, \"pP_\") {\n\t\treturn 0, fmt.Errorf(\"unsupported character in float\")\n\t}\n\treturn strconv.ParseFloat(s, 64)\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/README.txt",
"content": "PACKAGE\n\npackage goautoneg\nimport \"bitbucket.org/ww/goautoneg\"\n\nHTTP Content-Type Autonegotiation.\n\nThe functions in this package implement the behaviour specified in\nhttp://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html\n\nCopyright (c) 2011, Open Knowledge Foundation Ltd.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in\n the documentation and/or other materials provided with the\n distribution.\n\n Neither the name of the Open Knowledge Foundation Ltd. nor the\n names of its contributors may be used to endorse or promote\n products derived from this software without specific prior written\n permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nHOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\nFUNCTIONS\n\nfunc Negotiate(header string, alternatives []string) (content_type string)\nNegotiate the most appropriate content_type given the accept header\nand a list of alternatives.\n\nfunc ParseAccept(header string) (accept []Accept)\nParse an Accept Header string returning a sorted list\nof clauses\n\n\nTYPES\n\ntype Accept struct {\n Type, SubType string\n Q float32\n Params map[string]string\n}\nStructure to represent a clause in an HTTP Accept Header\n\n\nSUBDIRECTORIES\n\n\t.hg\n"
},
{
"path": "vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go",
"content": "/*\nCopyright (c) 2011, Open Knowledge Foundation Ltd.\nAll rights reserved.\n\nHTTP Content-Type Autonegotiation.\n\nThe functions in this package implement the behaviour specified in\nhttp://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in\n the documentation and/or other materials provided with the\n distribution.\n\n Neither the name of the Open Knowledge Foundation Ltd. nor the\n names of its contributors may be used to endorse or promote\n products derived from this software without specific prior written\n permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nHOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\n*/\npackage goautoneg\n\nimport (\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// Structure to represent a clause in an HTTP Accept Header\ntype Accept struct {\n\tType, SubType string\n\tQ float64\n\tParams map[string]string\n}\n\n// For internal use, so that we can use the sort interface\ntype accept_slice []Accept\n\nfunc (accept accept_slice) Len() int {\n\tslice := []Accept(accept)\n\treturn len(slice)\n}\n\nfunc (accept accept_slice) Less(i, j int) bool {\n\tslice := []Accept(accept)\n\tai, aj := slice[i], slice[j]\n\tif ai.Q > aj.Q {\n\t\treturn true\n\t}\n\tif ai.Type != \"*\" && aj.Type == \"*\" {\n\t\treturn true\n\t}\n\tif ai.SubType != \"*\" && aj.SubType == \"*\" {\n\t\treturn true\n\t}\n\treturn false\n}\n\nfunc (accept accept_slice) Swap(i, j int) {\n\tslice := []Accept(accept)\n\tslice[i], slice[j] = slice[j], slice[i]\n}\n\n// Parse an Accept Header string returning a sorted list\n// of clauses\nfunc ParseAccept(header string) (accept []Accept) {\n\tparts := strings.Split(header, \",\")\n\taccept = make([]Accept, 0, len(parts))\n\tfor _, part := range parts {\n\t\tpart := strings.Trim(part, \" \")\n\n\t\ta := Accept{}\n\t\ta.Params = make(map[string]string)\n\t\ta.Q = 1.0\n\n\t\tmrp := strings.Split(part, \";\")\n\n\t\tmedia_range := mrp[0]\n\t\tsp := strings.Split(media_range, \"/\")\n\t\ta.Type = strings.Trim(sp[0], \" \")\n\n\t\tswitch {\n\t\tcase len(sp) == 1 && a.Type == \"*\":\n\t\t\ta.SubType = \"*\"\n\t\tcase len(sp) == 2:\n\t\t\ta.SubType = strings.Trim(sp[1], \" \")\n\t\tdefault:\n\t\t\tcontinue\n\t\t}\n\n\t\tif len(mrp) == 1 {\n\t\t\taccept = append(accept, a)\n\t\t\tcontinue\n\t\t}\n\n\t\tfor _, param := range mrp[1:] {\n\t\t\tsp := strings.SplitN(param, \"=\", 2)\n\t\t\tif len(sp) != 2 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\ttoken := strings.Trim(sp[0], \" \")\n\t\t\tif token == \"q\" {\n\t\t\t\ta.Q, _ = strconv.ParseFloat(sp[1], 32)\n\t\t\t} else {\n\t\t\t\ta.Params[token] = strings.Trim(sp[1], \" \")\n\t\t\t}\n\t\t}\n\n\t\taccept = append(accept, a)\n\t}\n\n\tslice := accept_slice(accept)\n\tsort.Sort(slice)\n\n\treturn\n}\n\n// Negotiate the most appropriate content_type given the accept header\n// and a list of alternatives.\nfunc Negotiate(header string, alternatives []string) (content_type string) {\n\tasp := make([][]string, 0, len(alternatives))\n\tfor _, ctype := range alternatives {\n\t\tasp = append(asp, strings.SplitN(ctype, \"/\", 2))\n\t}\n\tfor _, clause := range ParseAccept(header) {\n\t\tfor i, ctsp := range asp {\n\t\t\tif clause.Type == ctsp[0] && clause.SubType == ctsp[1] {\n\t\t\t\tcontent_type = alternatives[i]\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif clause.Type == ctsp[0] && clause.SubType == \"*\" {\n\t\t\t\tcontent_type = alternatives[i]\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif clause.Type == \"*\" && clause.SubType == \"*\" {\n\t\t\t\tcontent_type = alternatives[i]\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t}\n\treturn\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/alert.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\ntype AlertStatus string\n\nconst (\n\tAlertFiring AlertStatus = \"firing\"\n\tAlertResolved AlertStatus = \"resolved\"\n)\n\n// Alert is a generic representation of an alert in the Prometheus eco-system.\ntype Alert struct {\n\t// Label value pairs for purpose of aggregation, matching, and disposition\n\t// dispatching. This must minimally include an \"alertname\" label.\n\tLabels LabelSet `json:\"labels\"`\n\n\t// Extra key/value information which does not define alert identity.\n\tAnnotations LabelSet `json:\"annotations\"`\n\n\t// The known time range for this alert. Both ends are optional.\n\tStartsAt time.Time `json:\"startsAt,omitempty\"`\n\tEndsAt time.Time `json:\"endsAt,omitempty\"`\n\tGeneratorURL string `json:\"generatorURL\"`\n}\n\n// Name returns the name of the alert. It is equivalent to the \"alertname\" label.\nfunc (a *Alert) Name() string {\n\treturn string(a.Labels[AlertNameLabel])\n}\n\n// Fingerprint returns a unique hash for the alert. It is equivalent to\n// the fingerprint of the alert's label set.\nfunc (a *Alert) Fingerprint() Fingerprint {\n\treturn a.Labels.Fingerprint()\n}\n\nfunc (a *Alert) String() string {\n\ts := fmt.Sprintf(\"%s[%s]\", a.Name(), a.Fingerprint().String()[:7])\n\tif a.Resolved() {\n\t\treturn s + \"[resolved]\"\n\t}\n\treturn s + \"[active]\"\n}\n\n// Resolved returns true iff the activity interval ended in the past.\nfunc (a *Alert) Resolved() bool {\n\treturn a.ResolvedAt(time.Now())\n}\n\n// ResolvedAt returns true off the activity interval ended before\n// the given timestamp.\nfunc (a *Alert) ResolvedAt(ts time.Time) bool {\n\tif a.EndsAt.IsZero() {\n\t\treturn false\n\t}\n\treturn !a.EndsAt.After(ts)\n}\n\n// Status returns the status of the alert.\nfunc (a *Alert) Status() AlertStatus {\n\tif a.Resolved() {\n\t\treturn AlertResolved\n\t}\n\treturn AlertFiring\n}\n\n// Validate checks whether the alert data is inconsistent.\nfunc (a *Alert) Validate() error {\n\tif a.StartsAt.IsZero() {\n\t\treturn fmt.Errorf(\"start time missing\")\n\t}\n\tif !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {\n\t\treturn fmt.Errorf(\"start time must be before end time\")\n\t}\n\tif err := a.Labels.Validate(); err != nil {\n\t\treturn fmt.Errorf(\"invalid label set: %s\", err)\n\t}\n\tif len(a.Labels) == 0 {\n\t\treturn fmt.Errorf(\"at least one label pair required\")\n\t}\n\tif err := a.Annotations.Validate(); err != nil {\n\t\treturn fmt.Errorf(\"invalid annotations: %s\", err)\n\t}\n\treturn nil\n}\n\n// Alert is a list of alerts that can be sorted in chronological order.\ntype Alerts []*Alert\n\nfunc (as Alerts) Len() int { return len(as) }\nfunc (as Alerts) Swap(i, j int) { as[i], as[j] = as[j], as[i] }\n\nfunc (as Alerts) Less(i, j int) bool {\n\tif as[i].StartsAt.Before(as[j].StartsAt) {\n\t\treturn true\n\t}\n\tif as[i].EndsAt.Before(as[j].EndsAt) {\n\t\treturn true\n\t}\n\treturn as[i].Fingerprint() < as[j].Fingerprint()\n}\n\n// HasFiring returns true iff one of the alerts is not resolved.\nfunc (as Alerts) HasFiring() bool {\n\tfor _, a := range as {\n\t\tif !a.Resolved() {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// Status returns StatusFiring iff at least one of the alerts is firing.\nfunc (as Alerts) Status() AlertStatus {\n\tif as.HasFiring() {\n\t\treturn AlertFiring\n\t}\n\treturn AlertResolved\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/fingerprinting.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n)\n\n// Fingerprint provides a hash-capable representation of a Metric.\n// For our purposes, FNV-1A 64-bit is used.\ntype Fingerprint uint64\n\n// FingerprintFromString transforms a string representation into a Fingerprint.\nfunc FingerprintFromString(s string) (Fingerprint, error) {\n\tnum, err := strconv.ParseUint(s, 16, 64)\n\treturn Fingerprint(num), err\n}\n\n// ParseFingerprint parses the input string into a fingerprint.\nfunc ParseFingerprint(s string) (Fingerprint, error) {\n\tnum, err := strconv.ParseUint(s, 16, 64)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn Fingerprint(num), nil\n}\n\nfunc (f Fingerprint) String() string {\n\treturn fmt.Sprintf(\"%016x\", uint64(f))\n}\n\n// Fingerprints represents a collection of Fingerprint subject to a given\n// natural sorting scheme. It implements sort.Interface.\ntype Fingerprints []Fingerprint\n\n// Len implements sort.Interface.\nfunc (f Fingerprints) Len() int {\n\treturn len(f)\n}\n\n// Less implements sort.Interface.\nfunc (f Fingerprints) Less(i, j int) bool {\n\treturn f[i] < f[j]\n}\n\n// Swap implements sort.Interface.\nfunc (f Fingerprints) Swap(i, j int) {\n\tf[i], f[j] = f[j], f[i]\n}\n\n// FingerprintSet is a set of Fingerprints.\ntype FingerprintSet map[Fingerprint]struct{}\n\n// Equal returns true if both sets contain the same elements (and not more).\nfunc (s FingerprintSet) Equal(o FingerprintSet) bool {\n\tif len(s) != len(o) {\n\t\treturn false\n\t}\n\n\tfor k := range s {\n\t\tif _, ok := o[k]; !ok {\n\t\t\treturn false\n\t\t}\n\t}\n\n\treturn true\n}\n\n// Intersection returns the elements contained in both sets.\nfunc (s FingerprintSet) Intersection(o FingerprintSet) FingerprintSet {\n\tmyLength, otherLength := len(s), len(o)\n\tif myLength == 0 || otherLength == 0 {\n\t\treturn FingerprintSet{}\n\t}\n\n\tsubSet := s\n\tsuperSet := o\n\n\tif otherLength < myLength {\n\t\tsubSet = o\n\t\tsuperSet = s\n\t}\n\n\tout := FingerprintSet{}\n\n\tfor k := range subSet {\n\t\tif _, ok := superSet[k]; ok {\n\t\t\tout[k] = struct{}{}\n\t\t}\n\t}\n\n\treturn out\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/fnv.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\n// Inline and byte-free variant of hash/fnv's fnv64a.\n\nconst (\n\toffset64 = 14695981039346656037\n\tprime64 = 1099511628211\n)\n\n// hashNew initializes a new fnv64a hash value.\nfunc hashNew() uint64 {\n\treturn offset64\n}\n\n// hashAdd adds a string to a fnv64a hash value, returning the updated hash.\nfunc hashAdd(h uint64, s string) uint64 {\n\tfor i := 0; i < len(s); i++ {\n\t\th ^= uint64(s[i])\n\t\th *= prime64\n\t}\n\treturn h\n}\n\n// hashAddByte adds a byte to a fnv64a hash value, returning the updated hash.\nfunc hashAddByte(h uint64, b byte) uint64 {\n\th ^= uint64(b)\n\th *= prime64\n\treturn h\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/labels.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"regexp\"\n\t\"strings\"\n\t\"unicode/utf8\"\n)\n\nconst (\n\t// AlertNameLabel is the name of the label containing the an alert's name.\n\tAlertNameLabel = \"alertname\"\n\n\t// ExportedLabelPrefix is the prefix to prepend to the label names present in\n\t// exported metrics if a label of the same name is added by the server.\n\tExportedLabelPrefix = \"exported_\"\n\n\t// MetricNameLabel is the label name indicating the metric name of a\n\t// timeseries.\n\tMetricNameLabel = \"__name__\"\n\n\t// SchemeLabel is the name of the label that holds the scheme on which to\n\t// scrape a target.\n\tSchemeLabel = \"__scheme__\"\n\n\t// AddressLabel is the name of the label that holds the address of\n\t// a scrape target.\n\tAddressLabel = \"__address__\"\n\n\t// MetricsPathLabel is the name of the label that holds the path on which to\n\t// scrape a target.\n\tMetricsPathLabel = \"__metrics_path__\"\n\n\t// ScrapeIntervalLabel is the name of the label that holds the scrape interval\n\t// used to scrape a target.\n\tScrapeIntervalLabel = \"__scrape_interval__\"\n\n\t// ScrapeTimeoutLabel is the name of the label that holds the scrape\n\t// timeout used to scrape a target.\n\tScrapeTimeoutLabel = \"__scrape_timeout__\"\n\n\t// ReservedLabelPrefix is a prefix which is not legal in user-supplied\n\t// label names.\n\tReservedLabelPrefix = \"__\"\n\n\t// MetaLabelPrefix is a prefix for labels that provide meta information.\n\t// Labels with this prefix are used for intermediate label processing and\n\t// will not be attached to time series.\n\tMetaLabelPrefix = \"__meta_\"\n\n\t// TmpLabelPrefix is a prefix for temporary labels as part of relabelling.\n\t// Labels with this prefix are used for intermediate label processing and\n\t// will not be attached to time series. This is reserved for use in\n\t// Prometheus configuration files by users.\n\tTmpLabelPrefix = \"__tmp_\"\n\n\t// ParamLabelPrefix is a prefix for labels that provide URL parameters\n\t// used to scrape a target.\n\tParamLabelPrefix = \"__param_\"\n\n\t// JobLabel is the label name indicating the job from which a timeseries\n\t// was scraped.\n\tJobLabel = \"job\"\n\n\t// InstanceLabel is the label name used for the instance label.\n\tInstanceLabel = \"instance\"\n\n\t// BucketLabel is used for the label that defines the upper bound of a\n\t// bucket of a histogram (\"le\" -> \"less or equal\").\n\tBucketLabel = \"le\"\n\n\t// QuantileLabel is used for the label that defines the quantile in a\n\t// summary.\n\tQuantileLabel = \"quantile\"\n)\n\n// LabelNameRE is a regular expression matching valid label names. Note that the\n// IsValid method of LabelName performs the same check but faster than a match\n// with this regular expression.\nvar LabelNameRE = regexp.MustCompile(\"^[a-zA-Z_][a-zA-Z0-9_]*$\")\n\n// A LabelName is a key for a LabelSet or Metric. It has a value associated\n// therewith.\ntype LabelName string\n\n// IsValid is true iff the label name matches the pattern of LabelNameRE. This\n// method, however, does not use LabelNameRE for the check but a much faster\n// hardcoded implementation.\nfunc (ln LabelName) IsValid() bool {\n\tif len(ln) == 0 {\n\t\treturn false\n\t}\n\tfor i, b := range ln {\n\t\tif !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || (b >= '0' && b <= '9' && i > 0)) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// UnmarshalYAML implements the yaml.Unmarshaler interface.\nfunc (ln *LabelName) UnmarshalYAML(unmarshal func(interface{}) error) error {\n\tvar s string\n\tif err := unmarshal(&s); err != nil {\n\t\treturn err\n\t}\n\tif !LabelName(s).IsValid() {\n\t\treturn fmt.Errorf(\"%q is not a valid label name\", s)\n\t}\n\t*ln = LabelName(s)\n\treturn nil\n}\n\n// UnmarshalJSON implements the json.Unmarshaler interface.\nfunc (ln *LabelName) UnmarshalJSON(b []byte) error {\n\tvar s string\n\tif err := json.Unmarshal(b, &s); err != nil {\n\t\treturn err\n\t}\n\tif !LabelName(s).IsValid() {\n\t\treturn fmt.Errorf(\"%q is not a valid label name\", s)\n\t}\n\t*ln = LabelName(s)\n\treturn nil\n}\n\n// LabelNames is a sortable LabelName slice. In implements sort.Interface.\ntype LabelNames []LabelName\n\nfunc (l LabelNames) Len() int {\n\treturn len(l)\n}\n\nfunc (l LabelNames) Less(i, j int) bool {\n\treturn l[i] < l[j]\n}\n\nfunc (l LabelNames) Swap(i, j int) {\n\tl[i], l[j] = l[j], l[i]\n}\n\nfunc (l LabelNames) String() string {\n\tlabelStrings := make([]string, 0, len(l))\n\tfor _, label := range l {\n\t\tlabelStrings = append(labelStrings, string(label))\n\t}\n\treturn strings.Join(labelStrings, \", \")\n}\n\n// A LabelValue is an associated value for a LabelName.\ntype LabelValue string\n\n// IsValid returns true iff the string is a valid UTF8.\nfunc (lv LabelValue) IsValid() bool {\n\treturn utf8.ValidString(string(lv))\n}\n\n// LabelValues is a sortable LabelValue slice. It implements sort.Interface.\ntype LabelValues []LabelValue\n\nfunc (l LabelValues) Len() int {\n\treturn len(l)\n}\n\nfunc (l LabelValues) Less(i, j int) bool {\n\treturn string(l[i]) < string(l[j])\n}\n\nfunc (l LabelValues) Swap(i, j int) {\n\tl[i], l[j] = l[j], l[i]\n}\n\n// LabelPair pairs a name with a value.\ntype LabelPair struct {\n\tName LabelName\n\tValue LabelValue\n}\n\n// LabelPairs is a sortable slice of LabelPair pointers. It implements\n// sort.Interface.\ntype LabelPairs []*LabelPair\n\nfunc (l LabelPairs) Len() int {\n\treturn len(l)\n}\n\nfunc (l LabelPairs) Less(i, j int) bool {\n\tswitch {\n\tcase l[i].Name > l[j].Name:\n\t\treturn false\n\tcase l[i].Name < l[j].Name:\n\t\treturn true\n\tcase l[i].Value > l[j].Value:\n\t\treturn false\n\tcase l[i].Value < l[j].Value:\n\t\treturn true\n\tdefault:\n\t\treturn false\n\t}\n}\n\nfunc (l LabelPairs) Swap(i, j int) {\n\tl[i], l[j] = l[j], l[i]\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/labelset.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"sort\"\n\t\"strings\"\n)\n\n// A LabelSet is a collection of LabelName and LabelValue pairs. The LabelSet\n// may be fully-qualified down to the point where it may resolve to a single\n// Metric in the data store or not. All operations that occur within the realm\n// of a LabelSet can emit a vector of Metric entities to which the LabelSet may\n// match.\ntype LabelSet map[LabelName]LabelValue\n\n// Validate checks whether all names and values in the label set\n// are valid.\nfunc (ls LabelSet) Validate() error {\n\tfor ln, lv := range ls {\n\t\tif !ln.IsValid() {\n\t\t\treturn fmt.Errorf(\"invalid name %q\", ln)\n\t\t}\n\t\tif !lv.IsValid() {\n\t\t\treturn fmt.Errorf(\"invalid value %q\", lv)\n\t\t}\n\t}\n\treturn nil\n}\n\n// Equal returns true iff both label sets have exactly the same key/value pairs.\nfunc (ls LabelSet) Equal(o LabelSet) bool {\n\tif len(ls) != len(o) {\n\t\treturn false\n\t}\n\tfor ln, lv := range ls {\n\t\tolv, ok := o[ln]\n\t\tif !ok {\n\t\t\treturn false\n\t\t}\n\t\tif olv != lv {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// Before compares the metrics, using the following criteria:\n//\n// If m has fewer labels than o, it is before o. If it has more, it is not.\n//\n// If the number of labels is the same, the superset of all label names is\n// sorted alphanumerically. The first differing label pair found in that order\n// determines the outcome: If the label does not exist at all in m, then m is\n// before o, and vice versa. Otherwise the label value is compared\n// alphanumerically.\n//\n// If m and o are equal, the method returns false.\nfunc (ls LabelSet) Before(o LabelSet) bool {\n\tif len(ls) < len(o) {\n\t\treturn true\n\t}\n\tif len(ls) > len(o) {\n\t\treturn false\n\t}\n\n\tlns := make(LabelNames, 0, len(ls)+len(o))\n\tfor ln := range ls {\n\t\tlns = append(lns, ln)\n\t}\n\tfor ln := range o {\n\t\tlns = append(lns, ln)\n\t}\n\t// It's probably not worth it to de-dup lns.\n\tsort.Sort(lns)\n\tfor _, ln := range lns {\n\t\tmlv, ok := ls[ln]\n\t\tif !ok {\n\t\t\treturn true\n\t\t}\n\t\tolv, ok := o[ln]\n\t\tif !ok {\n\t\t\treturn false\n\t\t}\n\t\tif mlv < olv {\n\t\t\treturn true\n\t\t}\n\t\tif mlv > olv {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn false\n}\n\n// Clone returns a copy of the label set.\nfunc (ls LabelSet) Clone() LabelSet {\n\tlsn := make(LabelSet, len(ls))\n\tfor ln, lv := range ls {\n\t\tlsn[ln] = lv\n\t}\n\treturn lsn\n}\n\n// Merge is a helper function to non-destructively merge two label sets.\nfunc (l LabelSet) Merge(other LabelSet) LabelSet {\n\tresult := make(LabelSet, len(l))\n\n\tfor k, v := range l {\n\t\tresult[k] = v\n\t}\n\n\tfor k, v := range other {\n\t\tresult[k] = v\n\t}\n\n\treturn result\n}\n\nfunc (l LabelSet) String() string {\n\tlstrs := make([]string, 0, len(l))\n\tfor l, v := range l {\n\t\tlstrs = append(lstrs, fmt.Sprintf(\"%s=%q\", l, v))\n\t}\n\n\tsort.Strings(lstrs)\n\treturn fmt.Sprintf(\"{%s}\", strings.Join(lstrs, \", \"))\n}\n\n// Fingerprint returns the LabelSet's fingerprint.\nfunc (ls LabelSet) Fingerprint() Fingerprint {\n\treturn labelSetToFingerprint(ls)\n}\n\n// FastFingerprint returns the LabelSet's Fingerprint calculated by a faster hashing\n// algorithm, which is, however, more susceptible to hash collisions.\nfunc (ls LabelSet) FastFingerprint() Fingerprint {\n\treturn labelSetToFastFingerprint(ls)\n}\n\n// UnmarshalJSON implements the json.Unmarshaler interface.\nfunc (l *LabelSet) UnmarshalJSON(b []byte) error {\n\tvar m map[LabelName]LabelValue\n\tif err := json.Unmarshal(b, &m); err != nil {\n\t\treturn err\n\t}\n\t// encoding/json only unmarshals maps of the form map[string]T. It treats\n\t// LabelName as a string and does not call its UnmarshalJSON method.\n\t// Thus, we have to replicate the behavior here.\n\tfor ln := range m {\n\t\tif !ln.IsValid() {\n\t\t\treturn fmt.Errorf(\"%q is not a valid label name\", ln)\n\t\t}\n\t}\n\t*l = LabelSet(m)\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/metric.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"fmt\"\n\t\"regexp\"\n\t\"sort\"\n\t\"strings\"\n)\n\nvar (\n\t// MetricNameRE is a regular expression matching valid metric\n\t// names. Note that the IsValidMetricName function performs the same\n\t// check but faster than a match with this regular expression.\n\tMetricNameRE = regexp.MustCompile(`^[a-zA-Z_:][a-zA-Z0-9_:]*$`)\n)\n\n// A Metric is similar to a LabelSet, but the key difference is that a Metric is\n// a singleton and refers to one and only one stream of samples.\ntype Metric LabelSet\n\n// Equal compares the metrics.\nfunc (m Metric) Equal(o Metric) bool {\n\treturn LabelSet(m).Equal(LabelSet(o))\n}\n\n// Before compares the metrics' underlying label sets.\nfunc (m Metric) Before(o Metric) bool {\n\treturn LabelSet(m).Before(LabelSet(o))\n}\n\n// Clone returns a copy of the Metric.\nfunc (m Metric) Clone() Metric {\n\tclone := make(Metric, len(m))\n\tfor k, v := range m {\n\t\tclone[k] = v\n\t}\n\treturn clone\n}\n\nfunc (m Metric) String() string {\n\tmetricName, hasName := m[MetricNameLabel]\n\tnumLabels := len(m) - 1\n\tif !hasName {\n\t\tnumLabels = len(m)\n\t}\n\tlabelStrings := make([]string, 0, numLabels)\n\tfor label, value := range m {\n\t\tif label != MetricNameLabel {\n\t\t\tlabelStrings = append(labelStrings, fmt.Sprintf(\"%s=%q\", label, value))\n\t\t}\n\t}\n\n\tswitch numLabels {\n\tcase 0:\n\t\tif hasName {\n\t\t\treturn string(metricName)\n\t\t}\n\t\treturn \"{}\"\n\tdefault:\n\t\tsort.Strings(labelStrings)\n\t\treturn fmt.Sprintf(\"%s{%s}\", metricName, strings.Join(labelStrings, \", \"))\n\t}\n}\n\n// Fingerprint returns a Metric's Fingerprint.\nfunc (m Metric) Fingerprint() Fingerprint {\n\treturn LabelSet(m).Fingerprint()\n}\n\n// FastFingerprint returns a Metric's Fingerprint calculated by a faster hashing\n// algorithm, which is, however, more susceptible to hash collisions.\nfunc (m Metric) FastFingerprint() Fingerprint {\n\treturn LabelSet(m).FastFingerprint()\n}\n\n// IsValidMetricName returns true iff name matches the pattern of MetricNameRE.\n// This function, however, does not use MetricNameRE for the check but a much\n// faster hardcoded implementation.\nfunc IsValidMetricName(n LabelValue) bool {\n\tif len(n) == 0 {\n\t\treturn false\n\t}\n\tfor i, b := range n {\n\t\tif !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || b == ':' || (b >= '0' && b <= '9' && i > 0)) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/model.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package model contains common data structures that are shared across\n// Prometheus components and libraries.\npackage model\n"
},
{
"path": "vendor/github.com/prometheus/common/model/signature.go",
"content": "// Copyright 2014 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"sort\"\n)\n\n// SeparatorByte is a byte that cannot occur in valid UTF-8 sequences and is\n// used to separate label names, label values, and other strings from each other\n// when calculating their combined hash value (aka signature aka fingerprint).\nconst SeparatorByte byte = 255\n\nvar (\n\t// cache the signature of an empty label set.\n\temptyLabelSignature = hashNew()\n)\n\n// LabelsToSignature returns a quasi-unique signature (i.e., fingerprint) for a\n// given label set. (Collisions are possible but unlikely if the number of label\n// sets the function is applied to is small.)\nfunc LabelsToSignature(labels map[string]string) uint64 {\n\tif len(labels) == 0 {\n\t\treturn emptyLabelSignature\n\t}\n\n\tlabelNames := make([]string, 0, len(labels))\n\tfor labelName := range labels {\n\t\tlabelNames = append(labelNames, labelName)\n\t}\n\tsort.Strings(labelNames)\n\n\tsum := hashNew()\n\tfor _, labelName := range labelNames {\n\t\tsum = hashAdd(sum, labelName)\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t\tsum = hashAdd(sum, labels[labelName])\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t}\n\treturn sum\n}\n\n// labelSetToFingerprint works exactly as LabelsToSignature but takes a LabelSet as\n// parameter (rather than a label map) and returns a Fingerprint.\nfunc labelSetToFingerprint(ls LabelSet) Fingerprint {\n\tif len(ls) == 0 {\n\t\treturn Fingerprint(emptyLabelSignature)\n\t}\n\n\tlabelNames := make(LabelNames, 0, len(ls))\n\tfor labelName := range ls {\n\t\tlabelNames = append(labelNames, labelName)\n\t}\n\tsort.Sort(labelNames)\n\n\tsum := hashNew()\n\tfor _, labelName := range labelNames {\n\t\tsum = hashAdd(sum, string(labelName))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t\tsum = hashAdd(sum, string(ls[labelName]))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t}\n\treturn Fingerprint(sum)\n}\n\n// labelSetToFastFingerprint works similar to labelSetToFingerprint but uses a\n// faster and less allocation-heavy hash function, which is more susceptible to\n// create hash collisions. Therefore, collision detection should be applied.\nfunc labelSetToFastFingerprint(ls LabelSet) Fingerprint {\n\tif len(ls) == 0 {\n\t\treturn Fingerprint(emptyLabelSignature)\n\t}\n\n\tvar result uint64\n\tfor labelName, labelValue := range ls {\n\t\tsum := hashNew()\n\t\tsum = hashAdd(sum, string(labelName))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t\tsum = hashAdd(sum, string(labelValue))\n\t\tresult ^= sum\n\t}\n\treturn Fingerprint(result)\n}\n\n// SignatureForLabels works like LabelsToSignature but takes a Metric as\n// parameter (rather than a label map) and only includes the labels with the\n// specified LabelNames into the signature calculation. The labels passed in\n// will be sorted by this function.\nfunc SignatureForLabels(m Metric, labels ...LabelName) uint64 {\n\tif len(labels) == 0 {\n\t\treturn emptyLabelSignature\n\t}\n\n\tsort.Sort(LabelNames(labels))\n\n\tsum := hashNew()\n\tfor _, label := range labels {\n\t\tsum = hashAdd(sum, string(label))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t\tsum = hashAdd(sum, string(m[label]))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t}\n\treturn sum\n}\n\n// SignatureWithoutLabels works like LabelsToSignature but takes a Metric as\n// parameter (rather than a label map) and excludes the labels with any of the\n// specified LabelNames from the signature calculation.\nfunc SignatureWithoutLabels(m Metric, labels map[LabelName]struct{}) uint64 {\n\tif len(m) == 0 {\n\t\treturn emptyLabelSignature\n\t}\n\n\tlabelNames := make(LabelNames, 0, len(m))\n\tfor labelName := range m {\n\t\tif _, exclude := labels[labelName]; !exclude {\n\t\t\tlabelNames = append(labelNames, labelName)\n\t\t}\n\t}\n\tif len(labelNames) == 0 {\n\t\treturn emptyLabelSignature\n\t}\n\tsort.Sort(labelNames)\n\n\tsum := hashNew()\n\tfor _, labelName := range labelNames {\n\t\tsum = hashAdd(sum, string(labelName))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t\tsum = hashAdd(sum, string(m[labelName]))\n\t\tsum = hashAddByte(sum, SeparatorByte)\n\t}\n\treturn sum\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/silence.go",
"content": "// Copyright 2015 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"regexp\"\n\t\"time\"\n)\n\n// Matcher describes a matches the value of a given label.\ntype Matcher struct {\n\tName LabelName `json:\"name\"`\n\tValue string `json:\"value\"`\n\tIsRegex bool `json:\"isRegex\"`\n}\n\nfunc (m *Matcher) UnmarshalJSON(b []byte) error {\n\ttype plain Matcher\n\tif err := json.Unmarshal(b, (*plain)(m)); err != nil {\n\t\treturn err\n\t}\n\n\tif len(m.Name) == 0 {\n\t\treturn fmt.Errorf(\"label name in matcher must not be empty\")\n\t}\n\tif m.IsRegex {\n\t\tif _, err := regexp.Compile(m.Value); err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\treturn nil\n}\n\n// Validate returns true iff all fields of the matcher have valid values.\nfunc (m *Matcher) Validate() error {\n\tif !m.Name.IsValid() {\n\t\treturn fmt.Errorf(\"invalid name %q\", m.Name)\n\t}\n\tif m.IsRegex {\n\t\tif _, err := regexp.Compile(m.Value); err != nil {\n\t\t\treturn fmt.Errorf(\"invalid regular expression %q\", m.Value)\n\t\t}\n\t} else if !LabelValue(m.Value).IsValid() || len(m.Value) == 0 {\n\t\treturn fmt.Errorf(\"invalid value %q\", m.Value)\n\t}\n\treturn nil\n}\n\n// Silence defines the representation of a silence definition in the Prometheus\n// eco-system.\ntype Silence struct {\n\tID uint64 `json:\"id,omitempty\"`\n\n\tMatchers []*Matcher `json:\"matchers\"`\n\n\tStartsAt time.Time `json:\"startsAt\"`\n\tEndsAt time.Time `json:\"endsAt\"`\n\n\tCreatedAt time.Time `json:\"createdAt,omitempty\"`\n\tCreatedBy string `json:\"createdBy\"`\n\tComment string `json:\"comment,omitempty\"`\n}\n\n// Validate returns true iff all fields of the silence have valid values.\nfunc (s *Silence) Validate() error {\n\tif len(s.Matchers) == 0 {\n\t\treturn fmt.Errorf(\"at least one matcher required\")\n\t}\n\tfor _, m := range s.Matchers {\n\t\tif err := m.Validate(); err != nil {\n\t\t\treturn fmt.Errorf(\"invalid matcher: %s\", err)\n\t\t}\n\t}\n\tif s.StartsAt.IsZero() {\n\t\treturn fmt.Errorf(\"start time missing\")\n\t}\n\tif s.EndsAt.IsZero() {\n\t\treturn fmt.Errorf(\"end time missing\")\n\t}\n\tif s.EndsAt.Before(s.StartsAt) {\n\t\treturn fmt.Errorf(\"start time must be before end time\")\n\t}\n\tif s.CreatedBy == \"\" {\n\t\treturn fmt.Errorf(\"creator information missing\")\n\t}\n\tif s.Comment == \"\" {\n\t\treturn fmt.Errorf(\"comment missing\")\n\t}\n\tif s.CreatedAt.IsZero() {\n\t\treturn fmt.Errorf(\"creation timestamp missing\")\n\t}\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/time.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"math\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n)\n\nconst (\n\t// MinimumTick is the minimum supported time resolution. This has to be\n\t// at least time.Second in order for the code below to work.\n\tminimumTick = time.Millisecond\n\t// second is the Time duration equivalent to one second.\n\tsecond = int64(time.Second / minimumTick)\n\t// The number of nanoseconds per minimum tick.\n\tnanosPerTick = int64(minimumTick / time.Nanosecond)\n\n\t// Earliest is the earliest Time representable. Handy for\n\t// initializing a high watermark.\n\tEarliest = Time(math.MinInt64)\n\t// Latest is the latest Time representable. Handy for initializing\n\t// a low watermark.\n\tLatest = Time(math.MaxInt64)\n)\n\n// Time is the number of milliseconds since the epoch\n// (1970-01-01 00:00 UTC) excluding leap seconds.\ntype Time int64\n\n// Interval describes an interval between two timestamps.\ntype Interval struct {\n\tStart, End Time\n}\n\n// Now returns the current time as a Time.\nfunc Now() Time {\n\treturn TimeFromUnixNano(time.Now().UnixNano())\n}\n\n// TimeFromUnix returns the Time equivalent to the Unix Time t\n// provided in seconds.\nfunc TimeFromUnix(t int64) Time {\n\treturn Time(t * second)\n}\n\n// TimeFromUnixNano returns the Time equivalent to the Unix Time\n// t provided in nanoseconds.\nfunc TimeFromUnixNano(t int64) Time {\n\treturn Time(t / nanosPerTick)\n}\n\n// Equal reports whether two Times represent the same instant.\nfunc (t Time) Equal(o Time) bool {\n\treturn t == o\n}\n\n// Before reports whether the Time t is before o.\nfunc (t Time) Before(o Time) bool {\n\treturn t < o\n}\n\n// After reports whether the Time t is after o.\nfunc (t Time) After(o Time) bool {\n\treturn t > o\n}\n\n// Add returns the Time t + d.\nfunc (t Time) Add(d time.Duration) Time {\n\treturn t + Time(d/minimumTick)\n}\n\n// Sub returns the Duration t - o.\nfunc (t Time) Sub(o Time) time.Duration {\n\treturn time.Duration(t-o) * minimumTick\n}\n\n// Time returns the time.Time representation of t.\nfunc (t Time) Time() time.Time {\n\treturn time.Unix(int64(t)/second, (int64(t)%second)*nanosPerTick)\n}\n\n// Unix returns t as a Unix time, the number of seconds elapsed\n// since January 1, 1970 UTC.\nfunc (t Time) Unix() int64 {\n\treturn int64(t) / second\n}\n\n// UnixNano returns t as a Unix time, the number of nanoseconds elapsed\n// since January 1, 1970 UTC.\nfunc (t Time) UnixNano() int64 {\n\treturn int64(t) * nanosPerTick\n}\n\n// The number of digits after the dot.\nvar dotPrecision = int(math.Log10(float64(second)))\n\n// String returns a string representation of the Time.\nfunc (t Time) String() string {\n\treturn strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64)\n}\n\n// MarshalJSON implements the json.Marshaler interface.\nfunc (t Time) MarshalJSON() ([]byte, error) {\n\treturn []byte(t.String()), nil\n}\n\n// UnmarshalJSON implements the json.Unmarshaler interface.\nfunc (t *Time) UnmarshalJSON(b []byte) error {\n\tp := strings.Split(string(b), \".\")\n\tswitch len(p) {\n\tcase 1:\n\t\tv, err := strconv.ParseInt(string(p[0]), 10, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\t*t = Time(v * second)\n\n\tcase 2:\n\t\tv, err := strconv.ParseInt(string(p[0]), 10, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tv *= second\n\n\t\tprec := dotPrecision - len(p[1])\n\t\tif prec < 0 {\n\t\t\tp[1] = p[1][:dotPrecision]\n\t\t} else if prec > 0 {\n\t\t\tp[1] = p[1] + strings.Repeat(\"0\", prec)\n\t\t}\n\n\t\tva, err := strconv.ParseInt(p[1], 10, 32)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t\t// If the value was something like -0.1 the negative is lost in the\n\t\t// parsing because of the leading zero, this ensures that we capture it.\n\t\tif len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 {\n\t\t\t*t = Time(v+va) * -1\n\t\t} else {\n\t\t\t*t = Time(v + va)\n\t\t}\n\n\tdefault:\n\t\treturn fmt.Errorf(\"invalid time %q\", string(b))\n\t}\n\treturn nil\n}\n\n// Duration wraps time.Duration. It is used to parse the custom duration format\n// from YAML.\n// This type should not propagate beyond the scope of input/output processing.\ntype Duration time.Duration\n\n// Set implements pflag/flag.Value\nfunc (d *Duration) Set(s string) error {\n\tvar err error\n\t*d, err = ParseDuration(s)\n\treturn err\n}\n\n// Type implements pflag.Value\nfunc (d *Duration) Type() string {\n\treturn \"duration\"\n}\n\nvar durationRE = regexp.MustCompile(\"^(([0-9]+)y)?(([0-9]+)w)?(([0-9]+)d)?(([0-9]+)h)?(([0-9]+)m)?(([0-9]+)s)?(([0-9]+)ms)?$\")\n\n// ParseDuration parses a string into a time.Duration, assuming that a year\n// always has 365d, a week always has 7d, and a day always has 24h.\nfunc ParseDuration(durationStr string) (Duration, error) {\n\tswitch durationStr {\n\tcase \"0\":\n\t\t// Allow 0 without a unit.\n\t\treturn 0, nil\n\tcase \"\":\n\t\treturn 0, errors.New(\"empty duration string\")\n\t}\n\tmatches := durationRE.FindStringSubmatch(durationStr)\n\tif matches == nil {\n\t\treturn 0, fmt.Errorf(\"not a valid duration string: %q\", durationStr)\n\t}\n\tvar dur time.Duration\n\n\t// Parse the match at pos `pos` in the regex and use `mult` to turn that\n\t// into ms, then add that value to the total parsed duration.\n\tvar overflowErr error\n\tm := func(pos int, mult time.Duration) {\n\t\tif matches[pos] == \"\" {\n\t\t\treturn\n\t\t}\n\t\tn, _ := strconv.Atoi(matches[pos])\n\n\t\t// Check if the provided duration overflows time.Duration (> ~ 290years).\n\t\tif n > int((1<<63-1)/mult/time.Millisecond) {\n\t\t\toverflowErr = errors.New(\"duration out of range\")\n\t\t}\n\t\td := time.Duration(n) * time.Millisecond\n\t\tdur += d * mult\n\n\t\tif dur < 0 {\n\t\t\toverflowErr = errors.New(\"duration out of range\")\n\t\t}\n\t}\n\n\tm(2, 1000*60*60*24*365) // y\n\tm(4, 1000*60*60*24*7) // w\n\tm(6, 1000*60*60*24) // d\n\tm(8, 1000*60*60) // h\n\tm(10, 1000*60) // m\n\tm(12, 1000) // s\n\tm(14, 1) // ms\n\n\treturn Duration(dur), overflowErr\n}\n\nfunc (d Duration) String() string {\n\tvar (\n\t\tms = int64(time.Duration(d) / time.Millisecond)\n\t\tr = \"\"\n\t)\n\tif ms == 0 {\n\t\treturn \"0s\"\n\t}\n\n\tf := func(unit string, mult int64, exact bool) {\n\t\tif exact && ms%mult != 0 {\n\t\t\treturn\n\t\t}\n\t\tif v := ms / mult; v > 0 {\n\t\t\tr += fmt.Sprintf(\"%d%s\", v, unit)\n\t\t\tms -= v * mult\n\t\t}\n\t}\n\n\t// Only format years and weeks if the remainder is zero, as it is often\n\t// easier to read 90d than 12w6d.\n\tf(\"y\", 1000*60*60*24*365, true)\n\tf(\"w\", 1000*60*60*24*7, true)\n\n\tf(\"d\", 1000*60*60*24, false)\n\tf(\"h\", 1000*60*60, false)\n\tf(\"m\", 1000*60, false)\n\tf(\"s\", 1000, false)\n\tf(\"ms\", 1, false)\n\n\treturn r\n}\n\n// MarshalJSON implements the json.Marshaler interface.\nfunc (d Duration) MarshalJSON() ([]byte, error) {\n\treturn json.Marshal(d.String())\n}\n\n// UnmarshalJSON implements the json.Unmarshaler interface.\nfunc (d *Duration) UnmarshalJSON(bytes []byte) error {\n\tvar s string\n\tif err := json.Unmarshal(bytes, &s); err != nil {\n\t\treturn err\n\t}\n\tdur, err := ParseDuration(s)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*d = dur\n\treturn nil\n}\n\n// MarshalText implements the encoding.TextMarshaler interface.\nfunc (d *Duration) MarshalText() ([]byte, error) {\n\treturn []byte(d.String()), nil\n}\n\n// UnmarshalText implements the encoding.TextUnmarshaler interface.\nfunc (d *Duration) UnmarshalText(text []byte) error {\n\tvar err error\n\t*d, err = ParseDuration(string(text))\n\treturn err\n}\n\n// MarshalYAML implements the yaml.Marshaler interface.\nfunc (d Duration) MarshalYAML() (interface{}, error) {\n\treturn d.String(), nil\n}\n\n// UnmarshalYAML implements the yaml.Unmarshaler interface.\nfunc (d *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {\n\tvar s string\n\tif err := unmarshal(&s); err != nil {\n\t\treturn err\n\t}\n\tdur, err := ParseDuration(s)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*d = dur\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/common/model/value.go",
"content": "// Copyright 2013 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage model\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"math\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n)\n\nvar (\n\t// ZeroSamplePair is the pseudo zero-value of SamplePair used to signal a\n\t// non-existing sample pair. It is a SamplePair with timestamp Earliest and\n\t// value 0.0. Note that the natural zero value of SamplePair has a timestamp\n\t// of 0, which is possible to appear in a real SamplePair and thus not\n\t// suitable to signal a non-existing SamplePair.\n\tZeroSamplePair = SamplePair{Timestamp: Earliest}\n\n\t// ZeroSample is the pseudo zero-value of Sample used to signal a\n\t// non-existing sample. It is a Sample with timestamp Earliest, value 0.0,\n\t// and metric nil. Note that the natural zero value of Sample has a timestamp\n\t// of 0, which is possible to appear in a real Sample and thus not suitable\n\t// to signal a non-existing Sample.\n\tZeroSample = Sample{Timestamp: Earliest}\n)\n\n// A SampleValue is a representation of a value for a given sample at a given\n// time.\ntype SampleValue float64\n\n// MarshalJSON implements json.Marshaler.\nfunc (v SampleValue) MarshalJSON() ([]byte, error) {\n\treturn json.Marshal(v.String())\n}\n\n// UnmarshalJSON implements json.Unmarshaler.\nfunc (v *SampleValue) UnmarshalJSON(b []byte) error {\n\tif len(b) < 2 || b[0] != '\"' || b[len(b)-1] != '\"' {\n\t\treturn fmt.Errorf(\"sample value must be a quoted string\")\n\t}\n\tf, err := strconv.ParseFloat(string(b[1:len(b)-1]), 64)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*v = SampleValue(f)\n\treturn nil\n}\n\n// Equal returns true if the value of v and o is equal or if both are NaN. Note\n// that v==o is false if both are NaN. If you want the conventional float\n// behavior, use == to compare two SampleValues.\nfunc (v SampleValue) Equal(o SampleValue) bool {\n\tif v == o {\n\t\treturn true\n\t}\n\treturn math.IsNaN(float64(v)) && math.IsNaN(float64(o))\n}\n\nfunc (v SampleValue) String() string {\n\treturn strconv.FormatFloat(float64(v), 'f', -1, 64)\n}\n\n// SamplePair pairs a SampleValue with a Timestamp.\ntype SamplePair struct {\n\tTimestamp Time\n\tValue SampleValue\n}\n\n// MarshalJSON implements json.Marshaler.\nfunc (s SamplePair) MarshalJSON() ([]byte, error) {\n\tt, err := json.Marshal(s.Timestamp)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tv, err := json.Marshal(s.Value)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn []byte(fmt.Sprintf(\"[%s,%s]\", t, v)), nil\n}\n\n// UnmarshalJSON implements json.Unmarshaler.\nfunc (s *SamplePair) UnmarshalJSON(b []byte) error {\n\tv := [...]json.Unmarshaler{&s.Timestamp, &s.Value}\n\treturn json.Unmarshal(b, &v)\n}\n\n// Equal returns true if this SamplePair and o have equal Values and equal\n// Timestamps. The semantics of Value equality is defined by SampleValue.Equal.\nfunc (s *SamplePair) Equal(o *SamplePair) bool {\n\treturn s == o || (s.Value.Equal(o.Value) && s.Timestamp.Equal(o.Timestamp))\n}\n\nfunc (s SamplePair) String() string {\n\treturn fmt.Sprintf(\"%s @[%s]\", s.Value, s.Timestamp)\n}\n\n// Sample is a sample pair associated with a metric.\ntype Sample struct {\n\tMetric Metric `json:\"metric\"`\n\tValue SampleValue `json:\"value\"`\n\tTimestamp Time `json:\"timestamp\"`\n}\n\n// Equal compares first the metrics, then the timestamp, then the value. The\n// semantics of value equality is defined by SampleValue.Equal.\nfunc (s *Sample) Equal(o *Sample) bool {\n\tif s == o {\n\t\treturn true\n\t}\n\n\tif !s.Metric.Equal(o.Metric) {\n\t\treturn false\n\t}\n\tif !s.Timestamp.Equal(o.Timestamp) {\n\t\treturn false\n\t}\n\n\treturn s.Value.Equal(o.Value)\n}\n\nfunc (s Sample) String() string {\n\treturn fmt.Sprintf(\"%s => %s\", s.Metric, SamplePair{\n\t\tTimestamp: s.Timestamp,\n\t\tValue: s.Value,\n\t})\n}\n\n// MarshalJSON implements json.Marshaler.\nfunc (s Sample) MarshalJSON() ([]byte, error) {\n\tv := struct {\n\t\tMetric Metric `json:\"metric\"`\n\t\tValue SamplePair `json:\"value\"`\n\t}{\n\t\tMetric: s.Metric,\n\t\tValue: SamplePair{\n\t\t\tTimestamp: s.Timestamp,\n\t\t\tValue: s.Value,\n\t\t},\n\t}\n\n\treturn json.Marshal(&v)\n}\n\n// UnmarshalJSON implements json.Unmarshaler.\nfunc (s *Sample) UnmarshalJSON(b []byte) error {\n\tv := struct {\n\t\tMetric Metric `json:\"metric\"`\n\t\tValue SamplePair `json:\"value\"`\n\t}{\n\t\tMetric: s.Metric,\n\t\tValue: SamplePair{\n\t\t\tTimestamp: s.Timestamp,\n\t\t\tValue: s.Value,\n\t\t},\n\t}\n\n\tif err := json.Unmarshal(b, &v); err != nil {\n\t\treturn err\n\t}\n\n\ts.Metric = v.Metric\n\ts.Timestamp = v.Value.Timestamp\n\ts.Value = v.Value.Value\n\n\treturn nil\n}\n\n// Samples is a sortable Sample slice. It implements sort.Interface.\ntype Samples []*Sample\n\nfunc (s Samples) Len() int {\n\treturn len(s)\n}\n\n// Less compares first the metrics, then the timestamp.\nfunc (s Samples) Less(i, j int) bool {\n\tswitch {\n\tcase s[i].Metric.Before(s[j].Metric):\n\t\treturn true\n\tcase s[j].Metric.Before(s[i].Metric):\n\t\treturn false\n\tcase s[i].Timestamp.Before(s[j].Timestamp):\n\t\treturn true\n\tdefault:\n\t\treturn false\n\t}\n}\n\nfunc (s Samples) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\n// Equal compares two sets of samples and returns true if they are equal.\nfunc (s Samples) Equal(o Samples) bool {\n\tif len(s) != len(o) {\n\t\treturn false\n\t}\n\n\tfor i, sample := range s {\n\t\tif !sample.Equal(o[i]) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// SampleStream is a stream of Values belonging to an attached COWMetric.\ntype SampleStream struct {\n\tMetric Metric `json:\"metric\"`\n\tValues []SamplePair `json:\"values\"`\n}\n\nfunc (ss SampleStream) String() string {\n\tvals := make([]string, len(ss.Values))\n\tfor i, v := range ss.Values {\n\t\tvals[i] = v.String()\n\t}\n\treturn fmt.Sprintf(\"%s =>\\n%s\", ss.Metric, strings.Join(vals, \"\\n\"))\n}\n\n// Value is a generic interface for values resulting from a query evaluation.\ntype Value interface {\n\tType() ValueType\n\tString() string\n}\n\nfunc (Matrix) Type() ValueType { return ValMatrix }\nfunc (Vector) Type() ValueType { return ValVector }\nfunc (*Scalar) Type() ValueType { return ValScalar }\nfunc (*String) Type() ValueType { return ValString }\n\ntype ValueType int\n\nconst (\n\tValNone ValueType = iota\n\tValScalar\n\tValVector\n\tValMatrix\n\tValString\n)\n\n// MarshalJSON implements json.Marshaler.\nfunc (et ValueType) MarshalJSON() ([]byte, error) {\n\treturn json.Marshal(et.String())\n}\n\nfunc (et *ValueType) UnmarshalJSON(b []byte) error {\n\tvar s string\n\tif err := json.Unmarshal(b, &s); err != nil {\n\t\treturn err\n\t}\n\tswitch s {\n\tcase \"\":\n\t\t*et = ValNone\n\tcase \"scalar\":\n\t\t*et = ValScalar\n\tcase \"vector\":\n\t\t*et = ValVector\n\tcase \"matrix\":\n\t\t*et = ValMatrix\n\tcase \"string\":\n\t\t*et = ValString\n\tdefault:\n\t\treturn fmt.Errorf(\"unknown value type %q\", s)\n\t}\n\treturn nil\n}\n\nfunc (e ValueType) String() string {\n\tswitch e {\n\tcase ValNone:\n\t\treturn \"\"\n\tcase ValScalar:\n\t\treturn \"scalar\"\n\tcase ValVector:\n\t\treturn \"vector\"\n\tcase ValMatrix:\n\t\treturn \"matrix\"\n\tcase ValString:\n\t\treturn \"string\"\n\t}\n\tpanic(\"ValueType.String: unhandled value type\")\n}\n\n// Scalar is a scalar value evaluated at the set timestamp.\ntype Scalar struct {\n\tValue SampleValue `json:\"value\"`\n\tTimestamp Time `json:\"timestamp\"`\n}\n\nfunc (s Scalar) String() string {\n\treturn fmt.Sprintf(\"scalar: %v @[%v]\", s.Value, s.Timestamp)\n}\n\n// MarshalJSON implements json.Marshaler.\nfunc (s Scalar) MarshalJSON() ([]byte, error) {\n\tv := strconv.FormatFloat(float64(s.Value), 'f', -1, 64)\n\treturn json.Marshal([...]interface{}{s.Timestamp, string(v)})\n}\n\n// UnmarshalJSON implements json.Unmarshaler.\nfunc (s *Scalar) UnmarshalJSON(b []byte) error {\n\tvar f string\n\tv := [...]interface{}{&s.Timestamp, &f}\n\n\tif err := json.Unmarshal(b, &v); err != nil {\n\t\treturn err\n\t}\n\n\tvalue, err := strconv.ParseFloat(f, 64)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"error parsing sample value: %s\", err)\n\t}\n\ts.Value = SampleValue(value)\n\treturn nil\n}\n\n// String is a string value evaluated at the set timestamp.\ntype String struct {\n\tValue string `json:\"value\"`\n\tTimestamp Time `json:\"timestamp\"`\n}\n\nfunc (s *String) String() string {\n\treturn s.Value\n}\n\n// MarshalJSON implements json.Marshaler.\nfunc (s String) MarshalJSON() ([]byte, error) {\n\treturn json.Marshal([]interface{}{s.Timestamp, s.Value})\n}\n\n// UnmarshalJSON implements json.Unmarshaler.\nfunc (s *String) UnmarshalJSON(b []byte) error {\n\tv := [...]interface{}{&s.Timestamp, &s.Value}\n\treturn json.Unmarshal(b, &v)\n}\n\n// Vector is basically only an alias for Samples, but the\n// contract is that in a Vector, all Samples have the same timestamp.\ntype Vector []*Sample\n\nfunc (vec Vector) String() string {\n\tentries := make([]string, len(vec))\n\tfor i, s := range vec {\n\t\tentries[i] = s.String()\n\t}\n\treturn strings.Join(entries, \"\\n\")\n}\n\nfunc (vec Vector) Len() int { return len(vec) }\nfunc (vec Vector) Swap(i, j int) { vec[i], vec[j] = vec[j], vec[i] }\n\n// Less compares first the metrics, then the timestamp.\nfunc (vec Vector) Less(i, j int) bool {\n\tswitch {\n\tcase vec[i].Metric.Before(vec[j].Metric):\n\t\treturn true\n\tcase vec[j].Metric.Before(vec[i].Metric):\n\t\treturn false\n\tcase vec[i].Timestamp.Before(vec[j].Timestamp):\n\t\treturn true\n\tdefault:\n\t\treturn false\n\t}\n}\n\n// Equal compares two sets of samples and returns true if they are equal.\nfunc (vec Vector) Equal(o Vector) bool {\n\tif len(vec) != len(o) {\n\t\treturn false\n\t}\n\n\tfor i, sample := range vec {\n\t\tif !sample.Equal(o[i]) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// Matrix is a list of time series.\ntype Matrix []*SampleStream\n\nfunc (m Matrix) Len() int { return len(m) }\nfunc (m Matrix) Less(i, j int) bool { return m[i].Metric.Before(m[j].Metric) }\nfunc (m Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }\n\nfunc (mat Matrix) String() string {\n\tmatCp := make(Matrix, len(mat))\n\tcopy(matCp, mat)\n\tsort.Sort(matCp)\n\n\tstrs := make([]string, len(matCp))\n\n\tfor i, ss := range matCp {\n\t\tstrs[i] = ss.String()\n\t}\n\n\treturn strings.Join(strs, \"\\n\")\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/.gitignore",
"content": "/testdata/fixtures/\n/fixtures\n"
},
{
"path": "vendor/github.com/prometheus/procfs/.golangci.yml",
"content": "---\nlinters:\n enable:\n - godot\n - revive\n\nlinter-settings:\n godot:\n capital: true\n exclude:\n # Ignore \"See: URL\"\n - 'See:'\n"
},
{
"path": "vendor/github.com/prometheus/procfs/CODE_OF_CONDUCT.md",
"content": "# Prometheus Community Code of Conduct\n\nPrometheus follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/main/code-of-conduct.md).\n"
},
{
"path": "vendor/github.com/prometheus/procfs/CONTRIBUTING.md",
"content": "# Contributing\n\nPrometheus uses GitHub to manage reviews of pull requests.\n\n* If you are a new contributor see: [Steps to Contribute](#steps-to-contribute)\n\n* If you have a trivial fix or improvement, go ahead and create a pull request,\n addressing (with `@...`) a suitable maintainer of this repository (see\n [MAINTAINERS.md](MAINTAINERS.md)) in the description of the pull request.\n\n* If you plan to do something more involved, first discuss your ideas\n on our [mailing list](https://groups.google.com/forum/?fromgroups#!forum/prometheus-developers).\n This will avoid unnecessary work and surely give you and us a good deal\n of inspiration. Also please see our [non-goals issue](https://github.com/prometheus/docs/issues/149) on areas that the Prometheus community doesn't plan to work on.\n\n* Relevant coding style guidelines are the [Go Code Review\n Comments](https://code.google.com/p/go-wiki/wiki/CodeReviewComments)\n and the _Formatting and style_ section of Peter Bourgon's [Go: Best\n Practices for Production\n Environments](https://peter.bourgon.org/go-in-production/#formatting-and-style).\n\n* Be sure to sign off on the [DCO](https://github.com/probot/dco#how-it-works)\n\n## Steps to Contribute\n\nShould you wish to work on an issue, please claim it first by commenting on the GitHub issue that you want to work on it. This is to prevent duplicated efforts from contributors on the same issue.\n\nPlease check the [`help-wanted`](https://github.com/prometheus/procfs/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) label to find issues that are good for getting started. If you have questions about one of the issues, with or without the tag, please comment on them and one of the maintainers will clarify it. For a quicker response, contact us over [IRC](https://prometheus.io/community).\n\nFor quickly compiling and testing your changes do:\n```\nmake test # Make sure all the tests pass before you commit and push :)\n```\n\nWe use [`golangci-lint`](https://github.com/golangci/golangci-lint) for linting the code. If it reports an issue and you think that the warning needs to be disregarded or is a false-positive, you can add a special comment `//nolint:linter1[,linter2,...]` before the offending line. Use this sparingly though, fixing the code to comply with the linter's recommendation is in general the preferred course of action.\n\n## Pull Request Checklist\n\n* Branch from the master branch and, if needed, rebase to the current master branch before submitting your pull request. If it doesn't merge cleanly with master you may be asked to rebase your changes.\n\n* Commits should be as small as possible, while ensuring that each commit is correct independently (i.e., each commit should compile and pass tests).\n\n* If your patch is not getting reviewed or you need a specific person to review it, you can @-reply a reviewer asking for a review in the pull request or a comment, or you can ask for a review on IRC channel [#prometheus](https://webchat.freenode.net/?channels=#prometheus) on irc.freenode.net (for the easiest start, [join via Riot](https://riot.im/app/#/room/#prometheus:matrix.org)).\n\n* Add tests relevant to the fixed bug or new feature.\n\n## Dependency management\n\nThe Prometheus project uses [Go modules](https://golang.org/cmd/go/#hdr-Modules__module_versions__and_more) to manage dependencies on external packages. This requires a working Go environment with version 1.12 or greater installed.\n\nAll dependencies are vendored in the `vendor/` directory.\n\nTo add or update a new dependency, use the `go get` command:\n\n```bash\n# Pick the latest tagged release.\ngo get example.com/some/module/pkg\n\n# Pick a specific version.\ngo get example.com/some/module/pkg@vX.Y.Z\n```\n\nTidy up the `go.mod` and `go.sum` files and copy the new/updated dependency to the `vendor/` directory:\n\n\n```bash\n# The GO111MODULE variable can be omitted when the code isn't located in GOPATH.\nGO111MODULE=on go mod tidy\n\nGO111MODULE=on go mod vendor\n```\n\nYou have to commit the changes to `go.mod`, `go.sum` and the `vendor/` directory before submitting the pull request.\n\n\n## API Implementation Guidelines\n\n### Naming and Documentation\n\nPublic functions and structs should normally be named according to the file(s) being read and parsed. For example, \nthe `fs.BuddyInfo()` function reads the file `/proc/buddyinfo`. In addition, the godoc for each public function\nshould contain the path to the file(s) being read and a URL of the linux kernel documentation describing the file(s).\n\n### Reading vs. Parsing\n\nMost functionality in this library consists of reading files and then parsing the text into structured data. In most\ncases reading and parsing should be separated into different functions/methods with a public `fs.Thing()` method and \na private `parseThing(r Reader)` function. This provides a logical separation and allows parsing to be tested\ndirectly without the need to read from the filesystem. Using a `Reader` argument is preferred over other data types\nsuch as `string` or `*File` because it provides the most flexibility regarding the data source. When a set of files \nin a directory needs to be parsed, then a `path` string parameter to the parse function can be used instead.\n\n### /proc and /sys filesystem I/O \n\nThe `proc` and `sys` filesystems are pseudo file systems and work a bit differently from standard disk I/O. \nMany of the files are changing continuously and the data being read can in some cases change between subsequent \nreads in the same file. Also, most of the files are relatively small (less than a few KBs), and system calls\nto the `stat` function will often return the wrong size. Therefore, for most files it's recommended to read the \nfull file in a single operation using an internal utility function called `util.ReadFileNoStat`.\nThis function is similar to `os.ReadFile`, but it avoids the system call to `stat` to get the current size of\nthe file.\n\nNote that parsing the file's contents can still be performed one line at a time. This is done by first reading \nthe full file, and then using a scanner on the `[]byte` or `string` containing the data.\n\n```\n data, err := util.ReadFileNoStat(\"/proc/cpuinfo\")\n if err != nil {\n return err\n }\n reader := bytes.NewReader(data)\n scanner := bufio.NewScanner(reader)\n```\n\nThe `/sys` filesystem contains many very small files which contain only a single numeric or text value. These files\ncan be read using an internal function called `util.SysReadFile` which is similar to `os.ReadFile` but does\nnot bother to check the size of the file before reading.\n```\n data, err := util.SysReadFile(\"/sys/class/power_supply/BAT0/capacity\")\n```\n\n"
},
{
"path": "vendor/github.com/prometheus/procfs/LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/prometheus/procfs/MAINTAINERS.md",
"content": "* Johannes 'fish' Ziemke @discordianfish\n* Paul Gier @pgier\n"
},
{
"path": "vendor/github.com/prometheus/procfs/Makefile",
"content": "# Copyright 2018 The Prometheus Authors\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\ninclude Makefile.common\n\n%/.unpacked: %.ttar\n\t@echo \">> extracting fixtures $*\"\n\t./ttar -C $(dir $*) -x -f $*.ttar\n\ttouch $@\n\nfixtures: testdata/fixtures/.unpacked\n\nupdate_fixtures:\n\trm -vf testdata/fixtures/.unpacked\n\t./ttar -c -f testdata/fixtures.ttar -C testdata/ fixtures/\n\n.PHONY: build\nbuild:\n\n.PHONY: test\ntest: testdata/fixtures/.unpacked common-test\n"
},
{
"path": "vendor/github.com/prometheus/procfs/Makefile.common",
"content": "# Copyright 2018 The Prometheus Authors\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\n# A common Makefile that includes rules to be reused in different prometheus projects.\n# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository!\n\n# Example usage :\n# Create the main Makefile in the root project directory.\n# include Makefile.common\n# customTarget:\n# \t@echo \">> Running customTarget\"\n#\n\n# Ensure GOBIN is not set during build so that promu is installed to the correct path\nunexport GOBIN\n\nGO ?= go\nGOFMT ?= $(GO)fmt\nFIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH)))\nGOOPTS ?=\nGOHOSTOS ?= $(shell $(GO) env GOHOSTOS)\nGOHOSTARCH ?= $(shell $(GO) env GOHOSTARCH)\n\nGO_VERSION ?= $(shell $(GO) version)\nGO_VERSION_NUMBER ?= $(word 3, $(GO_VERSION))\nPRE_GO_111 ?= $(shell echo $(GO_VERSION_NUMBER) | grep -E 'go1\\.(10|[0-9])\\.')\n\nPROMU := $(FIRST_GOPATH)/bin/promu\npkgs = ./...\n\nifeq (arm, $(GOHOSTARCH))\n\tGOHOSTARM ?= $(shell GOARM= $(GO) env GOARM)\n\tGO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)v$(GOHOSTARM)\nelse\n\tGO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)\nendif\n\nGOTEST := $(GO) test\nGOTEST_DIR :=\nifneq ($(CIRCLE_JOB),)\nifneq ($(shell which gotestsum),)\n\tGOTEST_DIR := test-results\n\tGOTEST := gotestsum --junitfile $(GOTEST_DIR)/unit-tests.xml --\nendif\nendif\n\nPROMU_VERSION ?= 0.13.0\nPROMU_URL := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz\n\nGOLANGCI_LINT :=\nGOLANGCI_LINT_OPTS ?=\nGOLANGCI_LINT_VERSION ?= v1.45.2\n# golangci-lint only supports linux, darwin and windows platforms on i386/amd64.\n# windows isn't included here because of the path separator being different.\nifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))\n\tifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386))\n\t\t# If we're in CI and there is an Actions file, that means the linter\n\t\t# is being run in Actions, so we don't need to run it here.\n\t\tifeq (,$(CIRCLE_JOB))\n\t\t\tGOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint\n\t\telse ifeq (,$(wildcard .github/workflows/golangci-lint.yml))\n\t\t\tGOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint\n\t\tendif\n\tendif\nendif\n\nPREFIX ?= $(shell pwd)\nBIN_DIR ?= $(shell pwd)\nDOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))\nDOCKERFILE_PATH ?= ./Dockerfile\nDOCKERBUILD_CONTEXT ?= ./\nDOCKER_REPO ?= prom\n\nDOCKER_ARCHS ?= amd64\n\nBUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))\nPUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))\nTAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))\n\nifeq ($(GOHOSTARCH),amd64)\n ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))\n # Only supported on amd64\n test-flags := -race\n endif\nendif\n\n# This rule is used to forward a target like \"build\" to \"common-build\". This\n# allows a new \"build\" target to be defined in a Makefile which includes this\n# one and override \"common-build\" without override warnings.\n%: common-% ;\n\n.PHONY: common-all\ncommon-all: precheck style check_license lint yamllint unused build test\n\n.PHONY: common-style\ncommon-style:\n\t@echo \">> checking code style\"\n\t@fmtRes=$$($(GOFMT) -d $$(find . -path ./vendor -prune -o -name '*.go' -print)); \\\n\tif [ -n \"$${fmtRes}\" ]; then \\\n\t\techo \"gofmt checking failed!\"; echo \"$${fmtRes}\"; echo; \\\n\t\techo \"Please ensure you are using $$($(GO) version) for formatting code.\"; \\\n\t\texit 1; \\\n\tfi\n\n.PHONY: common-check_license\ncommon-check_license:\n\t@echo \">> checking license header\"\n\t@licRes=$$(for file in $$(find . -type f -iname '*.go' ! -path './vendor/*') ; do \\\n awk 'NR<=3' $$file | grep -Eq \"(Copyright|generated|GENERATED)\" || echo $$file; \\\n done); \\\n if [ -n \"$${licRes}\" ]; then \\\n echo \"license header checking failed:\"; echo \"$${licRes}\"; \\\n exit 1; \\\n fi\n\n.PHONY: common-deps\ncommon-deps:\n\t@echo \">> getting dependencies\"\n\t$(GO) mod download\n\n.PHONY: update-go-deps\nupdate-go-deps:\n\t@echo \">> updating Go dependencies\"\n\t@for m in $$($(GO) list -mod=readonly -m -f '{{ if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all); do \\\n\t\t$(GO) get -d $$m; \\\n\tdone\n\t$(GO) mod tidy\n\n.PHONY: common-test-short\ncommon-test-short: $(GOTEST_DIR)\n\t@echo \">> running short tests\"\n\t$(GOTEST) -short $(GOOPTS) $(pkgs)\n\n.PHONY: common-test\ncommon-test: $(GOTEST_DIR)\n\t@echo \">> running all tests\"\n\t$(GOTEST) $(test-flags) $(GOOPTS) $(pkgs)\n\n$(GOTEST_DIR):\n\t@mkdir -p $@\n\n.PHONY: common-format\ncommon-format:\n\t@echo \">> formatting code\"\n\t$(GO) fmt $(pkgs)\n\n.PHONY: common-vet\ncommon-vet:\n\t@echo \">> vetting code\"\n\t$(GO) vet $(GOOPTS) $(pkgs)\n\n.PHONY: common-lint\ncommon-lint: $(GOLANGCI_LINT)\nifdef GOLANGCI_LINT\n\t@echo \">> running golangci-lint\"\n# 'go list' needs to be executed before staticcheck to prepopulate the modules cache.\n# Otherwise staticcheck might fail randomly for some reason not yet explained.\n\t$(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null\n\t$(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)\nendif\n\n.PHONY: common-yamllint\ncommon-yamllint:\n\t@echo \">> running yamllint on all YAML files in the repository\"\nifeq (, $(shell which yamllint))\n\t@echo \"yamllint not installed so skipping\"\nelse\n\tyamllint .\nendif\n\n# For backward-compatibility.\n.PHONY: common-staticcheck\ncommon-staticcheck: lint\n\n.PHONY: common-unused\ncommon-unused:\n\t@echo \">> running check for unused/missing packages in go.mod\"\n\t$(GO) mod tidy\n\t@git diff --exit-code -- go.sum go.mod\n\n.PHONY: common-build\ncommon-build: promu\n\t@echo \">> building binaries\"\n\t$(PROMU) build --prefix $(PREFIX) $(PROMU_BINARIES)\n\n.PHONY: common-tarball\ncommon-tarball: promu\n\t@echo \">> building release tarball\"\n\t$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)\n\n.PHONY: common-docker $(BUILD_DOCKER_ARCHS)\ncommon-docker: $(BUILD_DOCKER_ARCHS)\n$(BUILD_DOCKER_ARCHS): common-docker-%:\n\tdocker build -t \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)\" \\\n\t\t-f $(DOCKERFILE_PATH) \\\n\t\t--build-arg ARCH=\"$*\" \\\n\t\t--build-arg OS=\"linux\" \\\n\t\t$(DOCKERBUILD_CONTEXT)\n\n.PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)\ncommon-docker-publish: $(PUBLISH_DOCKER_ARCHS)\n$(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:\n\tdocker push \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)\"\n\nDOCKER_MAJOR_VERSION_TAG = $(firstword $(subst ., ,$(shell cat VERSION)))\n.PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)\ncommon-docker-tag-latest: $(TAG_DOCKER_ARCHS)\n$(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:\n\tdocker tag \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)\" \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest\"\n\tdocker tag \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)\" \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)\"\n\n.PHONY: common-docker-manifest\ncommon-docker-manifest:\n\tDOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)\" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(DOCKER_IMAGE_TAG))\n\tDOCKER_CLI_EXPERIMENTAL=enabled docker manifest push \"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)\"\n\n.PHONY: promu\npromu: $(PROMU)\n\n$(PROMU):\n\t$(eval PROMU_TMP := $(shell mktemp -d))\n\tcurl -s -L $(PROMU_URL) | tar -xvzf - -C $(PROMU_TMP)\n\tmkdir -p $(FIRST_GOPATH)/bin\n\tcp $(PROMU_TMP)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu\n\trm -r $(PROMU_TMP)\n\n.PHONY: proto\nproto:\n\t@echo \">> generating code from proto files\"\n\t@./scripts/genproto.sh\n\nifdef GOLANGCI_LINT\n$(GOLANGCI_LINT):\n\tmkdir -p $(FIRST_GOPATH)/bin\n\tcurl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_LINT_VERSION)/install.sh \\\n\t\t| sed -e '/install -d/d' \\\n\t\t| sh -s -- -b $(FIRST_GOPATH)/bin $(GOLANGCI_LINT_VERSION)\nendif\n\n.PHONY: precheck\nprecheck::\n\ndefine PRECHECK_COMMAND_template =\nprecheck:: $(1)_precheck\n\nPRECHECK_COMMAND_$(1) ?= $(1) $$(strip $$(PRECHECK_OPTIONS_$(1)))\n.PHONY: $(1)_precheck\n$(1)_precheck:\n\t@if ! $$(PRECHECK_COMMAND_$(1)) 1>/dev/null 2>&1; then \\\n\t\techo \"Execution of '$$(PRECHECK_COMMAND_$(1))' command failed. Is $(1) installed?\"; \\\n\t\texit 1; \\\n\tfi\nendef\n"
},
{
"path": "vendor/github.com/prometheus/procfs/NOTICE",
"content": "procfs provides functions to retrieve system, kernel and process\nmetrics from the pseudo-filesystem proc.\n\nCopyright 2014-2015 The Prometheus Authors\n\nThis product includes software developed at\nSoundCloud Ltd. (http://soundcloud.com/).\n"
},
{
"path": "vendor/github.com/prometheus/procfs/README.md",
"content": "# procfs\n\nThis package provides functions to retrieve system, kernel, and process\nmetrics from the pseudo-filesystems /proc and /sys.\n\n*WARNING*: This package is a work in progress. Its API may still break in\nbackwards-incompatible ways without warnings. Use it at your own risk.\n\n[](https://pkg.go.dev/github.com/prometheus/procfs)\n[](https://circleci.com/gh/prometheus/procfs/tree/master)\n[](https://goreportcard.com/report/github.com/prometheus/procfs)\n\n## Usage\n\nThe procfs library is organized by packages based on whether the gathered data is coming from\n/proc, /sys, or both. Each package contains an `FS` type which represents the path to either /proc, \n/sys, or both. For example, cpu statistics are gathered from\n`/proc/stat` and are available via the root procfs package. First, the proc filesystem mount\npoint is initialized, and then the stat information is read.\n\n```go\nfs, err := procfs.NewFS(\"/proc\")\nstats, err := fs.Stat()\n```\n\nSome sub-packages such as `blockdevice`, require access to both the proc and sys filesystems.\n\n```go\n fs, err := blockdevice.NewFS(\"/proc\", \"/sys\")\n stats, err := fs.ProcDiskstats()\n```\n\n## Package Organization\n\nThe packages in this project are organized according to (1) whether the data comes from the `/proc` or\n`/sys` filesystem and (2) the type of information being retrieved. For example, most process information\ncan be gathered from the functions in the root `procfs` package. Information about block devices such as disk drives\nis available in the `blockdevices` sub-package.\n\n## Building and Testing\n\nThe procfs library is intended to be built as part of another application, so there are no distributable binaries. \nHowever, most of the API includes unit tests which can be run with `make test`.\n\n### Updating Test Fixtures\n\nThe procfs library includes a set of test fixtures which include many example files from\nthe `/proc` and `/sys` filesystems. These fixtures are included as a [ttar](https://github.com/ideaship/ttar) file\nwhich is extracted automatically during testing. To add/update the test fixtures, first\nensure the `fixtures` directory is up to date by removing the existing directory and then\nextracting the ttar file using `make fixtures/.unpacked` or just `make test`.\n\n```bash\nrm -rf fixtures\nmake test\n```\n\nNext, make the required changes to the extracted files in the `fixtures` directory. When\nthe changes are complete, run `make update_fixtures` to create a new `fixtures.ttar` file\nbased on the updated `fixtures` directory. And finally, verify the changes using\n`git diff fixtures.ttar`.\n"
},
{
"path": "vendor/github.com/prometheus/procfs/SECURITY.md",
"content": "# Reporting a security issue\n\nThe Prometheus security policy, including how to report vulnerabilities, can be\nfound here:\n\n\n"
},
{
"path": "vendor/github.com/prometheus/procfs/arp.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"net\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// Learned from include/uapi/linux/if_arp.h.\nconst (\n\t// completed entry (ha valid).\n\tATFComplete = 0x02\n\t// permanent entry.\n\tATFPermanent = 0x04\n\t// Publish entry.\n\tATFPublish = 0x08\n\t// Has requested trailers.\n\tATFUseTrailers = 0x10\n\t// Obsoleted: Want to use a netmask (only for proxy entries).\n\tATFNetmask = 0x20\n\t// Don't answer this addresses.\n\tATFDontPublish = 0x40\n)\n\n// ARPEntry contains a single row of the columnar data represented in\n// /proc/net/arp.\ntype ARPEntry struct {\n\t// IP address\n\tIPAddr net.IP\n\t// MAC address\n\tHWAddr net.HardwareAddr\n\t// Name of the device\n\tDevice string\n\t// Flags\n\tFlags byte\n}\n\n// GatherARPEntries retrieves all the ARP entries, parse the relevant columns,\n// and then return a slice of ARPEntry's.\nfunc (fs FS) GatherARPEntries() ([]ARPEntry, error) {\n\tdata, err := os.ReadFile(fs.proc.Path(\"net/arp\"))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error reading arp %q: %w\", fs.proc.Path(\"net/arp\"), err)\n\t}\n\n\treturn parseARPEntries(data)\n}\n\nfunc parseARPEntries(data []byte) ([]ARPEntry, error) {\n\tlines := strings.Split(string(data), \"\\n\")\n\tentries := make([]ARPEntry, 0)\n\tvar err error\n\tconst (\n\t\texpectedDataWidth = 6\n\t\texpectedHeaderWidth = 9\n\t)\n\tfor _, line := range lines {\n\t\tcolumns := strings.Fields(line)\n\t\twidth := len(columns)\n\n\t\tif width == expectedHeaderWidth || width == 0 {\n\t\t\tcontinue\n\t\t} else if width == expectedDataWidth {\n\t\t\tentry, err := parseARPEntry(columns)\n\t\t\tif err != nil {\n\t\t\t\treturn []ARPEntry{}, fmt.Errorf(\"failed to parse ARP entry: %w\", err)\n\t\t\t}\n\t\t\tentries = append(entries, entry)\n\t\t} else {\n\t\t\treturn []ARPEntry{}, fmt.Errorf(\"%d columns were detected, but %d were expected\", width, expectedDataWidth)\n\t\t}\n\n\t}\n\n\treturn entries, err\n}\n\nfunc parseARPEntry(columns []string) (ARPEntry, error) {\n\tentry := ARPEntry{Device: columns[5]}\n\tip := net.ParseIP(columns[0])\n\tentry.IPAddr = ip\n\n\tif mac, err := net.ParseMAC(columns[3]); err == nil {\n\t\tentry.HWAddr = mac\n\t} else {\n\t\treturn ARPEntry{}, err\n\t}\n\n\tif flags, err := strconv.ParseUint(columns[2], 0, 8); err == nil {\n\t\tentry.Flags = byte(flags)\n\t} else {\n\t\treturn ARPEntry{}, err\n\t}\n\n\treturn entry, nil\n}\n\n// IsComplete returns true if ARP entry is marked with complete flag.\nfunc (entry *ARPEntry) IsComplete() bool {\n\treturn entry.Flags&ATFComplete != 0\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/buddyinfo.go",
"content": "// Copyright 2017 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// A BuddyInfo is the details parsed from /proc/buddyinfo.\n// The data is comprised of an array of free fragments of each size.\n// The sizes are 2^n*PAGE_SIZE, where n is the array index.\ntype BuddyInfo struct {\n\tNode string\n\tZone string\n\tSizes []float64\n}\n\n// BuddyInfo reads the buddyinfo statistics from the specified `proc` filesystem.\nfunc (fs FS) BuddyInfo() ([]BuddyInfo, error) {\n\tfile, err := os.Open(fs.proc.Path(\"buddyinfo\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer file.Close()\n\n\treturn parseBuddyInfo(file)\n}\n\nfunc parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) {\n\tvar (\n\t\tbuddyInfo = []BuddyInfo{}\n\t\tscanner = bufio.NewScanner(r)\n\t\tbucketCount = -1\n\t)\n\n\tfor scanner.Scan() {\n\t\tvar err error\n\t\tline := scanner.Text()\n\t\tparts := strings.Fields(line)\n\n\t\tif len(parts) < 4 {\n\t\t\treturn nil, fmt.Errorf(\"invalid number of fields when parsing buddyinfo\")\n\t\t}\n\n\t\tnode := strings.TrimRight(parts[1], \",\")\n\t\tzone := strings.TrimRight(parts[3], \",\")\n\t\tarraySize := len(parts[4:])\n\n\t\tif bucketCount == -1 {\n\t\t\tbucketCount = arraySize\n\t\t} else {\n\t\t\tif bucketCount != arraySize {\n\t\t\t\treturn nil, fmt.Errorf(\"mismatch in number of buddyinfo buckets, previous count %d, new count %d\", bucketCount, arraySize)\n\t\t\t}\n\t\t}\n\n\t\tsizes := make([]float64, arraySize)\n\t\tfor i := 0; i < arraySize; i++ {\n\t\t\tsizes[i], err = strconv.ParseFloat(parts[i+4], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, fmt.Errorf(\"invalid value in buddyinfo: %w\", err)\n\t\t\t}\n\t\t}\n\n\t\tbuddyInfo = append(buddyInfo, BuddyInfo{node, zone, sizes})\n\t}\n\n\treturn buddyInfo, scanner.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cmdline.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// CmdLine returns the command line of the kernel.\nfunc (fs FS) CmdLine() ([]string, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"cmdline\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn strings.Fields(string(data)), nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux\n// +build linux\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// CPUInfo contains general information about a system CPU found in /proc/cpuinfo.\ntype CPUInfo struct {\n\tProcessor uint\n\tVendorID string\n\tCPUFamily string\n\tModel string\n\tModelName string\n\tStepping string\n\tMicrocode string\n\tCPUMHz float64\n\tCacheSize string\n\tPhysicalID string\n\tSiblings uint\n\tCoreID string\n\tCPUCores uint\n\tAPICID string\n\tInitialAPICID string\n\tFPU string\n\tFPUException string\n\tCPUIDLevel uint\n\tWP string\n\tFlags []string\n\tBugs []string\n\tBogoMips float64\n\tCLFlushSize uint\n\tCacheAlignment uint\n\tAddressSizes string\n\tPowerManagement string\n}\n\nvar (\n\tcpuinfoClockRegexp = regexp.MustCompile(`([\\d.]+)`)\n\tcpuinfoS390XProcessorRegexp = regexp.MustCompile(`^processor\\s+(\\d+):.*`)\n)\n\n// CPUInfo returns information about current system CPUs.\n// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt\nfunc (fs FS) CPUInfo() ([]CPUInfo, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"cpuinfo\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseCPUInfo(data)\n}\n\nfunc parseCPUInfoX86(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\t// find the first \"processor\" line\n\tfirstLine := firstNonEmptyLine(scanner)\n\tif !strings.HasPrefix(firstLine, \"processor\") || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tv, err := strconv.ParseUint(field[1], 0, 32)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tfirstcpu := CPUInfo{Processor: uint(v)}\n\tcpuinfo := []CPUInfo{firstcpu}\n\ti := 0\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"processor\":\n\t\t\tcpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor\n\t\t\ti++\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].Processor = uint(v)\n\t\tcase \"vendor\", \"vendor_id\":\n\t\t\tcpuinfo[i].VendorID = field[1]\n\t\tcase \"cpu family\":\n\t\t\tcpuinfo[i].CPUFamily = field[1]\n\t\tcase \"model\":\n\t\t\tcpuinfo[i].Model = field[1]\n\t\tcase \"model name\":\n\t\t\tcpuinfo[i].ModelName = field[1]\n\t\tcase \"stepping\":\n\t\t\tcpuinfo[i].Stepping = field[1]\n\t\tcase \"microcode\":\n\t\t\tcpuinfo[i].Microcode = field[1]\n\t\tcase \"cpu MHz\":\n\t\t\tv, err := strconv.ParseFloat(field[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUMHz = v\n\t\tcase \"cache size\":\n\t\t\tcpuinfo[i].CacheSize = field[1]\n\t\tcase \"physical id\":\n\t\t\tcpuinfo[i].PhysicalID = field[1]\n\t\tcase \"siblings\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].Siblings = uint(v)\n\t\tcase \"core id\":\n\t\t\tcpuinfo[i].CoreID = field[1]\n\t\tcase \"cpu cores\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUCores = uint(v)\n\t\tcase \"apicid\":\n\t\t\tcpuinfo[i].APICID = field[1]\n\t\tcase \"initial apicid\":\n\t\t\tcpuinfo[i].InitialAPICID = field[1]\n\t\tcase \"fpu\":\n\t\t\tcpuinfo[i].FPU = field[1]\n\t\tcase \"fpu_exception\":\n\t\t\tcpuinfo[i].FPUException = field[1]\n\t\tcase \"cpuid level\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUIDLevel = uint(v)\n\t\tcase \"wp\":\n\t\t\tcpuinfo[i].WP = field[1]\n\t\tcase \"flags\":\n\t\t\tcpuinfo[i].Flags = strings.Fields(field[1])\n\t\tcase \"bugs\":\n\t\t\tcpuinfo[i].Bugs = strings.Fields(field[1])\n\t\tcase \"bogomips\":\n\t\t\tv, err := strconv.ParseFloat(field[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].BogoMips = v\n\t\tcase \"clflush size\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CLFlushSize = uint(v)\n\t\tcase \"cache_alignment\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CacheAlignment = uint(v)\n\t\tcase \"address sizes\":\n\t\t\tcpuinfo[i].AddressSizes = field[1]\n\t\tcase \"power management\":\n\t\t\tcpuinfo[i].PowerManagement = field[1]\n\t\t}\n\t}\n\treturn cpuinfo, nil\n}\n\nfunc parseCPUInfoARM(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\tfirstLine := firstNonEmptyLine(scanner)\n\tmatch, _ := regexp.MatchString(\"^[Pp]rocessor\", firstLine)\n\tif !match || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tcpuinfo := []CPUInfo{}\n\tfeaturesLine := \"\"\n\tcommonCPUInfo := CPUInfo{}\n\ti := 0\n\tif strings.TrimSpace(field[0]) == \"Processor\" {\n\t\tcommonCPUInfo = CPUInfo{ModelName: field[1]}\n\t\ti = -1\n\t} else {\n\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tfirstcpu := CPUInfo{Processor: uint(v)}\n\t\tcpuinfo = []CPUInfo{firstcpu}\n\t}\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"processor\":\n\t\t\tcpuinfo = append(cpuinfo, commonCPUInfo) // start of the next processor\n\t\t\ti++\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].Processor = uint(v)\n\t\tcase \"BogoMIPS\":\n\t\t\tif i == -1 {\n\t\t\t\tcpuinfo = append(cpuinfo, commonCPUInfo) // There is only one processor\n\t\t\t\ti++\n\t\t\t\tcpuinfo[i].Processor = 0\n\t\t\t}\n\t\t\tv, err := strconv.ParseFloat(field[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].BogoMips = v\n\t\tcase \"Features\":\n\t\t\tfeaturesLine = line\n\t\tcase \"model name\":\n\t\t\tcpuinfo[i].ModelName = field[1]\n\t\t}\n\t}\n\tfields := strings.SplitN(featuresLine, \": \", 2)\n\tfor i := range cpuinfo {\n\t\tcpuinfo[i].Flags = strings.Fields(fields[1])\n\t}\n\treturn cpuinfo, nil\n\n}\n\nfunc parseCPUInfoS390X(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\tfirstLine := firstNonEmptyLine(scanner)\n\tif !strings.HasPrefix(firstLine, \"vendor_id\") || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tcpuinfo := []CPUInfo{}\n\tcommonCPUInfo := CPUInfo{VendorID: field[1]}\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"bogomips per cpu\":\n\t\t\tv, err := strconv.ParseFloat(field[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcommonCPUInfo.BogoMips = v\n\t\tcase \"features\":\n\t\t\tcommonCPUInfo.Flags = strings.Fields(field[1])\n\t\t}\n\t\tif strings.HasPrefix(line, \"processor\") {\n\t\t\tmatch := cpuinfoS390XProcessorRegexp.FindStringSubmatch(line)\n\t\t\tif len(match) < 2 {\n\t\t\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t\t\t}\n\t\t\tcpu := commonCPUInfo\n\t\t\tv, err := strconv.ParseUint(match[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpu.Processor = uint(v)\n\t\t\tcpuinfo = append(cpuinfo, cpu)\n\t\t}\n\t\tif strings.HasPrefix(line, \"cpu number\") {\n\t\t\tbreak\n\t\t}\n\t}\n\n\ti := 0\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"cpu number\":\n\t\t\ti++\n\t\tcase \"cpu MHz dynamic\":\n\t\t\tclock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))\n\t\t\tv, err := strconv.ParseFloat(clock, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUMHz = v\n\t\tcase \"physical id\":\n\t\t\tcpuinfo[i].PhysicalID = field[1]\n\t\tcase \"core id\":\n\t\t\tcpuinfo[i].CoreID = field[1]\n\t\tcase \"cpu cores\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUCores = uint(v)\n\t\tcase \"siblings\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].Siblings = uint(v)\n\t\t}\n\t}\n\n\treturn cpuinfo, nil\n}\n\nfunc parseCPUInfoMips(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\t// find the first \"processor\" line\n\tfirstLine := firstNonEmptyLine(scanner)\n\tif !strings.HasPrefix(firstLine, \"system type\") || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tcpuinfo := []CPUInfo{}\n\tsystemType := field[1]\n\n\ti := 0\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"processor\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\ti = int(v)\n\t\t\tcpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor\n\t\t\tcpuinfo[i].Processor = uint(v)\n\t\t\tcpuinfo[i].VendorID = systemType\n\t\tcase \"cpu model\":\n\t\t\tcpuinfo[i].ModelName = field[1]\n\t\tcase \"BogoMIPS\":\n\t\t\tv, err := strconv.ParseFloat(field[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].BogoMips = v\n\t\t}\n\t}\n\treturn cpuinfo, nil\n}\n\nfunc parseCPUInfoPPC(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\tfirstLine := firstNonEmptyLine(scanner)\n\tif !strings.HasPrefix(firstLine, \"processor\") || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tv, err := strconv.ParseUint(field[1], 0, 32)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tfirstcpu := CPUInfo{Processor: uint(v)}\n\tcpuinfo := []CPUInfo{firstcpu}\n\ti := 0\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"processor\":\n\t\t\tcpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor\n\t\t\ti++\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].Processor = uint(v)\n\t\tcase \"cpu\":\n\t\t\tcpuinfo[i].VendorID = field[1]\n\t\tcase \"clock\":\n\t\t\tclock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))\n\t\t\tv, err := strconv.ParseFloat(clock, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tcpuinfo[i].CPUMHz = v\n\t\t}\n\t}\n\treturn cpuinfo, nil\n}\n\nfunc parseCPUInfoRISCV(info []byte) ([]CPUInfo, error) {\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\n\tfirstLine := firstNonEmptyLine(scanner)\n\tif !strings.HasPrefix(firstLine, \"processor\") || !strings.Contains(firstLine, \":\") {\n\t\treturn nil, fmt.Errorf(\"invalid cpuinfo file: %q\", firstLine)\n\t}\n\tfield := strings.SplitN(firstLine, \": \", 2)\n\tv, err := strconv.ParseUint(field[1], 0, 32)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tfirstcpu := CPUInfo{Processor: uint(v)}\n\tcpuinfo := []CPUInfo{firstcpu}\n\ti := 0\n\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !strings.Contains(line, \":\") {\n\t\t\tcontinue\n\t\t}\n\t\tfield := strings.SplitN(line, \": \", 2)\n\t\tswitch strings.TrimSpace(field[0]) {\n\t\tcase \"processor\":\n\t\t\tv, err := strconv.ParseUint(field[1], 0, 32)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\ti = int(v)\n\t\t\tcpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor\n\t\t\tcpuinfo[i].Processor = uint(v)\n\t\tcase \"hart\":\n\t\t\tcpuinfo[i].CoreID = field[1]\n\t\tcase \"isa\":\n\t\t\tcpuinfo[i].ModelName = field[1]\n\t\t}\n\t}\n\treturn cpuinfo, nil\n}\n\nfunc parseCPUInfoDummy(_ []byte) ([]CPUInfo, error) { // nolint:unused,deadcode\n\treturn nil, errors.New(\"not implemented\")\n}\n\n// firstNonEmptyLine advances the scanner to the first non-empty line\n// and returns the contents of that line.\nfunc firstNonEmptyLine(scanner *bufio.Scanner) string {\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif strings.TrimSpace(line) != \"\" {\n\t\t\treturn line\n\t\t}\n\t}\n\treturn \"\"\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_armx.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && (arm || arm64)\n// +build linux\n// +build arm arm64\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoARM\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_mipsx.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && (mips || mipsle || mips64 || mips64le)\n// +build linux\n// +build mips mipsle mips64 mips64le\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoMips\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_others.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && !386 && !amd64 && !arm && !arm64 && !mips && !mips64 && !mips64le && !mipsle && !ppc64 && !ppc64le && !riscv64 && !s390x\n// +build linux,!386,!amd64,!arm,!arm64,!mips,!mips64,!mips64le,!mipsle,!ppc64,!ppc64le,!riscv64,!s390x\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoDummy\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_ppcx.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && (ppc64 || ppc64le)\n// +build linux\n// +build ppc64 ppc64le\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoPPC\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_riscvx.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && (riscv || riscv64)\n// +build linux\n// +build riscv riscv64\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoRISCV\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_s390x.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux\n// +build linux\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoS390X\n"
},
{
"path": "vendor/github.com/prometheus/procfs/cpuinfo_x86.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build linux && (386 || amd64)\n// +build linux\n// +build 386 amd64\n\npackage procfs\n\nvar parseCPUInfo = parseCPUInfoX86\n"
},
{
"path": "vendor/github.com/prometheus/procfs/crypto.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Crypto holds info parsed from /proc/crypto.\ntype Crypto struct {\n\tAlignmask *uint64\n\tAsync bool\n\tBlocksize *uint64\n\tChunksize *uint64\n\tCtxsize *uint64\n\tDigestsize *uint64\n\tDriver string\n\tGeniv string\n\tInternal string\n\tIvsize *uint64\n\tMaxauthsize *uint64\n\tMaxKeysize *uint64\n\tMinKeysize *uint64\n\tModule string\n\tName string\n\tPriority *int64\n\tRefcnt *int64\n\tSeedsize *uint64\n\tSelftest string\n\tType string\n\tWalksize *uint64\n}\n\n// Crypto parses an crypto-file (/proc/crypto) and returns a slice of\n// structs containing the relevant info. More information available here:\n// https://kernel.readthedocs.io/en/sphinx-samples/crypto-API.html\nfunc (fs FS) Crypto() ([]Crypto, error) {\n\tpath := fs.proc.Path(\"crypto\")\n\tb, err := util.ReadFileNoStat(path)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error reading crypto %q: %w\", path, err)\n\t}\n\n\tcrypto, err := parseCrypto(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error parsing crypto %q: %w\", path, err)\n\t}\n\n\treturn crypto, nil\n}\n\n// parseCrypto parses a /proc/crypto stream into Crypto elements.\nfunc parseCrypto(r io.Reader) ([]Crypto, error) {\n\tvar out []Crypto\n\n\ts := bufio.NewScanner(r)\n\tfor s.Scan() {\n\t\ttext := s.Text()\n\t\tswitch {\n\t\tcase strings.HasPrefix(text, \"name\"):\n\t\t\t// Each crypto element begins with its name.\n\t\t\tout = append(out, Crypto{})\n\t\tcase text == \"\":\n\t\t\tcontinue\n\t\t}\n\n\t\tkv := strings.Split(text, \":\")\n\t\tif len(kv) != 2 {\n\t\t\treturn nil, fmt.Errorf(\"malformed crypto line: %q\", text)\n\t\t}\n\n\t\tk := strings.TrimSpace(kv[0])\n\t\tv := strings.TrimSpace(kv[1])\n\n\t\t// Parse the key/value pair into the currently focused element.\n\t\tc := &out[len(out)-1]\n\t\tif err := c.parseKV(k, v); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tif err := s.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn out, nil\n}\n\n// parseKV parses a key/value pair into the appropriate field of c.\nfunc (c *Crypto) parseKV(k, v string) error {\n\tvp := util.NewValueParser(v)\n\n\tswitch k {\n\tcase \"async\":\n\t\t// Interpret literal yes as true.\n\t\tc.Async = v == \"yes\"\n\tcase \"blocksize\":\n\t\tc.Blocksize = vp.PUInt64()\n\tcase \"chunksize\":\n\t\tc.Chunksize = vp.PUInt64()\n\tcase \"digestsize\":\n\t\tc.Digestsize = vp.PUInt64()\n\tcase \"driver\":\n\t\tc.Driver = v\n\tcase \"geniv\":\n\t\tc.Geniv = v\n\tcase \"internal\":\n\t\tc.Internal = v\n\tcase \"ivsize\":\n\t\tc.Ivsize = vp.PUInt64()\n\tcase \"maxauthsize\":\n\t\tc.Maxauthsize = vp.PUInt64()\n\tcase \"max keysize\":\n\t\tc.MaxKeysize = vp.PUInt64()\n\tcase \"min keysize\":\n\t\tc.MinKeysize = vp.PUInt64()\n\tcase \"module\":\n\t\tc.Module = v\n\tcase \"name\":\n\t\tc.Name = v\n\tcase \"priority\":\n\t\tc.Priority = vp.PInt64()\n\tcase \"refcnt\":\n\t\tc.Refcnt = vp.PInt64()\n\tcase \"seedsize\":\n\t\tc.Seedsize = vp.PUInt64()\n\tcase \"selftest\":\n\t\tc.Selftest = v\n\tcase \"type\":\n\t\tc.Type = v\n\tcase \"walksize\":\n\t\tc.Walksize = vp.PUInt64()\n\t}\n\n\treturn vp.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/doc.go",
"content": "// Copyright 2014 Prometheus Team\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// Package procfs provides functions to retrieve system, kernel and process\n// metrics from the pseudo-filesystem proc.\n//\n// Example:\n//\n// package main\n//\n// import (\n// \t\"fmt\"\n// \t\"log\"\n//\n// \t\"github.com/prometheus/procfs\"\n// )\n//\n// func main() {\n// \tp, err := procfs.Self()\n// \tif err != nil {\n// \t\tlog.Fatalf(\"could not get process: %s\", err)\n// \t}\n//\n// \tstat, err := p.Stat()\n// \tif err != nil {\n// \t\tlog.Fatalf(\"could not get process stat: %s\", err)\n// \t}\n//\n// \tfmt.Printf(\"command: %s\\n\", stat.Comm)\n// \tfmt.Printf(\"cpu time: %fs\\n\", stat.CPUTime())\n// \tfmt.Printf(\"vsize: %dB\\n\", stat.VirtualMemory())\n// \tfmt.Printf(\"rss: %dB\\n\", stat.ResidentMemory())\n// }\n//\npackage procfs\n"
},
{
"path": "vendor/github.com/prometheus/procfs/fs.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"github.com/prometheus/procfs/internal/fs\"\n)\n\n// FS represents the pseudo-filesystem sys, which provides an interface to\n// kernel data structures.\ntype FS struct {\n\tproc fs.FS\n}\n\n// DefaultMountPoint is the common mount point of the proc filesystem.\nconst DefaultMountPoint = fs.DefaultProcMountPoint\n\n// NewDefaultFS returns a new proc FS mounted under the default proc mountPoint.\n// It will error if the mount point directory can't be read or is a file.\nfunc NewDefaultFS() (FS, error) {\n\treturn NewFS(DefaultMountPoint)\n}\n\n// NewFS returns a new proc FS mounted under the given proc mountPoint. It will error\n// if the mount point directory can't be read or is a file.\nfunc NewFS(mountPoint string) (FS, error) {\n\tfs, err := fs.NewFS(mountPoint)\n\tif err != nil {\n\t\treturn FS{}, err\n\t}\n\treturn FS{fs}, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/fscache.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Fscacheinfo represents fscache statistics.\ntype Fscacheinfo struct {\n\t// Number of index cookies allocated\n\tIndexCookiesAllocated uint64\n\t// data storage cookies allocated\n\tDataStorageCookiesAllocated uint64\n\t// Number of special cookies allocated\n\tSpecialCookiesAllocated uint64\n\t// Number of objects allocated\n\tObjectsAllocated uint64\n\t// Number of object allocation failures\n\tObjectAllocationsFailure uint64\n\t// Number of objects that reached the available state\n\tObjectsAvailable uint64\n\t// Number of objects that reached the dead state\n\tObjectsDead uint64\n\t// Number of objects that didn't have a coherency check\n\tObjectsWithoutCoherencyCheck uint64\n\t// Number of objects that passed a coherency check\n\tObjectsWithCoherencyCheck uint64\n\t// Number of objects that needed a coherency data update\n\tObjectsNeedCoherencyCheckUpdate uint64\n\t// Number of objects that were declared obsolete\n\tObjectsDeclaredObsolete uint64\n\t// Number of pages marked as being cached\n\tPagesMarkedAsBeingCached uint64\n\t// Number of uncache page requests seen\n\tUncachePagesRequestSeen uint64\n\t// Number of acquire cookie requests seen\n\tAcquireCookiesRequestSeen uint64\n\t// Number of acq reqs given a NULL parent\n\tAcquireRequestsWithNullParent uint64\n\t// Number of acq reqs rejected due to no cache available\n\tAcquireRequestsRejectedNoCacheAvailable uint64\n\t// Number of acq reqs succeeded\n\tAcquireRequestsSucceeded uint64\n\t// Number of acq reqs rejected due to error\n\tAcquireRequestsRejectedDueToError uint64\n\t// Number of acq reqs failed on ENOMEM\n\tAcquireRequestsFailedDueToEnomem uint64\n\t// Number of lookup calls made on cache backends\n\tLookupsNumber uint64\n\t// Number of negative lookups made\n\tLookupsNegative uint64\n\t// Number of positive lookups made\n\tLookupsPositive uint64\n\t// Number of objects created by lookup\n\tObjectsCreatedByLookup uint64\n\t// Number of lookups timed out and requeued\n\tLookupsTimedOutAndRequed uint64\n\tInvalidationsNumber uint64\n\tInvalidationsRunning uint64\n\t// Number of update cookie requests seen\n\tUpdateCookieRequestSeen uint64\n\t// Number of upd reqs given a NULL parent\n\tUpdateRequestsWithNullParent uint64\n\t// Number of upd reqs granted CPU time\n\tUpdateRequestsRunning uint64\n\t// Number of relinquish cookie requests seen\n\tRelinquishCookiesRequestSeen uint64\n\t// Number of rlq reqs given a NULL parent\n\tRelinquishCookiesWithNullParent uint64\n\t// Number of rlq reqs waited on completion of creation\n\tRelinquishRequestsWaitingCompleteCreation uint64\n\t// Relinqs rtr\n\tRelinquishRetries uint64\n\t// Number of attribute changed requests seen\n\tAttributeChangedRequestsSeen uint64\n\t// Number of attr changed requests queued\n\tAttributeChangedRequestsQueued uint64\n\t// Number of attr changed rejected -ENOBUFS\n\tAttributeChangedRejectDueToEnobufs uint64\n\t// Number of attr changed failed -ENOMEM\n\tAttributeChangedFailedDueToEnomem uint64\n\t// Number of attr changed ops given CPU time\n\tAttributeChangedOps uint64\n\t// Number of allocation requests seen\n\tAllocationRequestsSeen uint64\n\t// Number of successful alloc reqs\n\tAllocationOkRequests uint64\n\t// Number of alloc reqs that waited on lookup completion\n\tAllocationWaitingOnLookup uint64\n\t// Number of alloc reqs rejected -ENOBUFS\n\tAllocationsRejectedDueToEnobufs uint64\n\t// Number of alloc reqs aborted -ERESTARTSYS\n\tAllocationsAbortedDueToErestartsys uint64\n\t// Number of alloc reqs submitted\n\tAllocationOperationsSubmitted uint64\n\t// Number of alloc reqs waited for CPU time\n\tAllocationsWaitedForCPU uint64\n\t// Number of alloc reqs aborted due to object death\n\tAllocationsAbortedDueToObjectDeath uint64\n\t// Number of retrieval (read) requests seen\n\tRetrievalsReadRequests uint64\n\t// Number of successful retr reqs\n\tRetrievalsOk uint64\n\t// Number of retr reqs that waited on lookup completion\n\tRetrievalsWaitingLookupCompletion uint64\n\t// Number of retr reqs returned -ENODATA\n\tRetrievalsReturnedEnodata uint64\n\t// Number of retr reqs rejected -ENOBUFS\n\tRetrievalsRejectedDueToEnobufs uint64\n\t// Number of retr reqs aborted -ERESTARTSYS\n\tRetrievalsAbortedDueToErestartsys uint64\n\t// Number of retr reqs failed -ENOMEM\n\tRetrievalsFailedDueToEnomem uint64\n\t// Number of retr reqs submitted\n\tRetrievalsRequests uint64\n\t// Number of retr reqs waited for CPU time\n\tRetrievalsWaitingCPU uint64\n\t// Number of retr reqs aborted due to object death\n\tRetrievalsAbortedDueToObjectDeath uint64\n\t// Number of storage (write) requests seen\n\tStoreWriteRequests uint64\n\t// Number of successful store reqs\n\tStoreSuccessfulRequests uint64\n\t// Number of store reqs on a page already pending storage\n\tStoreRequestsOnPendingStorage uint64\n\t// Number of store reqs rejected -ENOBUFS\n\tStoreRequestsRejectedDueToEnobufs uint64\n\t// Number of store reqs failed -ENOMEM\n\tStoreRequestsFailedDueToEnomem uint64\n\t// Number of store reqs submitted\n\tStoreRequestsSubmitted uint64\n\t// Number of store reqs granted CPU time\n\tStoreRequestsRunning uint64\n\t// Number of pages given store req processing time\n\tStorePagesWithRequestsProcessing uint64\n\t// Number of store reqs deleted from tracking tree\n\tStoreRequestsDeleted uint64\n\t// Number of store reqs over store limit\n\tStoreRequestsOverStoreLimit uint64\n\t// Number of release reqs against pages with no pending store\n\tReleaseRequestsAgainstPagesWithNoPendingStorage uint64\n\t// Number of release reqs against pages stored by time lock granted\n\tReleaseRequestsAgainstPagesStoredByTimeLockGranted uint64\n\t// Number of release reqs ignored due to in-progress store\n\tReleaseRequestsIgnoredDueToInProgressStore uint64\n\t// Number of page stores cancelled due to release req\n\tPageStoresCancelledByReleaseRequests uint64\n\tVmscanWaiting uint64\n\t// Number of times async ops added to pending queues\n\tOpsPending uint64\n\t// Number of times async ops given CPU time\n\tOpsRunning uint64\n\t// Number of times async ops queued for processing\n\tOpsEnqueued uint64\n\t// Number of async ops cancelled\n\tOpsCancelled uint64\n\t// Number of async ops rejected due to object lookup/create failure\n\tOpsRejected uint64\n\t// Number of async ops initialised\n\tOpsInitialised uint64\n\t// Number of async ops queued for deferred release\n\tOpsDeferred uint64\n\t// Number of async ops released (should equal ini=N when idle)\n\tOpsReleased uint64\n\t// Number of deferred-release async ops garbage collected\n\tOpsGarbageCollected uint64\n\t// Number of in-progress alloc_object() cache ops\n\tCacheopAllocationsinProgress uint64\n\t// Number of in-progress lookup_object() cache ops\n\tCacheopLookupObjectInProgress uint64\n\t// Number of in-progress lookup_complete() cache ops\n\tCacheopLookupCompleteInPorgress uint64\n\t// Number of in-progress grab_object() cache ops\n\tCacheopGrabObjectInProgress uint64\n\tCacheopInvalidations uint64\n\t// Number of in-progress update_object() cache ops\n\tCacheopUpdateObjectInProgress uint64\n\t// Number of in-progress drop_object() cache ops\n\tCacheopDropObjectInProgress uint64\n\t// Number of in-progress put_object() cache ops\n\tCacheopPutObjectInProgress uint64\n\t// Number of in-progress attr_changed() cache ops\n\tCacheopAttributeChangeInProgress uint64\n\t// Number of in-progress sync_cache() cache ops\n\tCacheopSyncCacheInProgress uint64\n\t// Number of in-progress read_or_alloc_page() cache ops\n\tCacheopReadOrAllocPageInProgress uint64\n\t// Number of in-progress read_or_alloc_pages() cache ops\n\tCacheopReadOrAllocPagesInProgress uint64\n\t// Number of in-progress allocate_page() cache ops\n\tCacheopAllocatePageInProgress uint64\n\t// Number of in-progress allocate_pages() cache ops\n\tCacheopAllocatePagesInProgress uint64\n\t// Number of in-progress write_page() cache ops\n\tCacheopWritePagesInProgress uint64\n\t// Number of in-progress uncache_page() cache ops\n\tCacheopUncachePagesInProgress uint64\n\t// Number of in-progress dissociate_pages() cache ops\n\tCacheopDissociatePagesInProgress uint64\n\t// Number of object lookups/creations rejected due to lack of space\n\tCacheevLookupsAndCreationsRejectedLackSpace uint64\n\t// Number of stale objects deleted\n\tCacheevStaleObjectsDeleted uint64\n\t// Number of objects retired when relinquished\n\tCacheevRetiredWhenReliquished uint64\n\t// Number of objects culled\n\tCacheevObjectsCulled uint64\n}\n\n// Fscacheinfo returns information about current fscache statistics.\n// See https://www.kernel.org/doc/Documentation/filesystems/caching/fscache.txt\nfunc (fs FS) Fscacheinfo() (Fscacheinfo, error) {\n\tb, err := util.ReadFileNoStat(fs.proc.Path(\"fs/fscache/stats\"))\n\tif err != nil {\n\t\treturn Fscacheinfo{}, err\n\t}\n\n\tm, err := parseFscacheinfo(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn Fscacheinfo{}, fmt.Errorf(\"failed to parse Fscacheinfo: %w\", err)\n\t}\n\n\treturn *m, nil\n}\n\nfunc setFSCacheFields(fields []string, setFields ...*uint64) error {\n\tvar err error\n\tif len(fields) < len(setFields) {\n\t\treturn fmt.Errorf(\"Insufficient number of fields, expected %v, got %v\", len(setFields), len(fields))\n\t}\n\n\tfor i := range setFields {\n\t\t*setFields[i], err = strconv.ParseUint(strings.Split(fields[i], \"=\")[1], 0, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc parseFscacheinfo(r io.Reader) (*Fscacheinfo, error) {\n\tvar m Fscacheinfo\n\ts := bufio.NewScanner(r)\n\tfor s.Scan() {\n\t\tfields := strings.Fields(s.Text())\n\t\tif len(fields) < 2 {\n\t\t\treturn nil, fmt.Errorf(\"malformed Fscacheinfo line: %q\", s.Text())\n\t\t}\n\n\t\tswitch fields[0] {\n\t\tcase \"Cookies:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.IndexCookiesAllocated, &m.DataStorageCookiesAllocated,\n\t\t\t\t&m.SpecialCookiesAllocated)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Objects:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.ObjectsAllocated, &m.ObjectAllocationsFailure,\n\t\t\t\t&m.ObjectsAvailable, &m.ObjectsDead)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"ChkAux\":\n\t\t\terr := setFSCacheFields(fields[2:], &m.ObjectsWithoutCoherencyCheck, &m.ObjectsWithCoherencyCheck,\n\t\t\t\t&m.ObjectsNeedCoherencyCheckUpdate, &m.ObjectsDeclaredObsolete)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Pages\":\n\t\t\terr := setFSCacheFields(fields[2:], &m.PagesMarkedAsBeingCached, &m.UncachePagesRequestSeen)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Acquire:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.AcquireCookiesRequestSeen, &m.AcquireRequestsWithNullParent,\n\t\t\t\t&m.AcquireRequestsRejectedNoCacheAvailable, &m.AcquireRequestsSucceeded, &m.AcquireRequestsRejectedDueToError,\n\t\t\t\t&m.AcquireRequestsFailedDueToEnomem)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Lookups:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.LookupsNumber, &m.LookupsNegative, &m.LookupsPositive,\n\t\t\t\t&m.ObjectsCreatedByLookup, &m.LookupsTimedOutAndRequed)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Invals\":\n\t\t\terr := setFSCacheFields(fields[2:], &m.InvalidationsNumber, &m.InvalidationsRunning)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Updates:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.UpdateCookieRequestSeen, &m.UpdateRequestsWithNullParent,\n\t\t\t\t&m.UpdateRequestsRunning)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Relinqs:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.RelinquishCookiesRequestSeen, &m.RelinquishCookiesWithNullParent,\n\t\t\t\t&m.RelinquishRequestsWaitingCompleteCreation, &m.RelinquishRetries)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"AttrChg:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.AttributeChangedRequestsSeen, &m.AttributeChangedRequestsQueued,\n\t\t\t\t&m.AttributeChangedRejectDueToEnobufs, &m.AttributeChangedFailedDueToEnomem, &m.AttributeChangedOps)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Allocs\":\n\t\t\tif strings.Split(fields[2], \"=\")[0] == \"n\" {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.AllocationRequestsSeen, &m.AllocationOkRequests,\n\t\t\t\t\t&m.AllocationWaitingOnLookup, &m.AllocationsRejectedDueToEnobufs, &m.AllocationsAbortedDueToErestartsys)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.AllocationOperationsSubmitted, &m.AllocationsWaitedForCPU,\n\t\t\t\t\t&m.AllocationsAbortedDueToObjectDeath)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t}\n\t\tcase \"Retrvls:\":\n\t\t\tif strings.Split(fields[1], \"=\")[0] == \"n\" {\n\t\t\t\terr := setFSCacheFields(fields[1:], &m.RetrievalsReadRequests, &m.RetrievalsOk, &m.RetrievalsWaitingLookupCompletion,\n\t\t\t\t\t&m.RetrievalsReturnedEnodata, &m.RetrievalsRejectedDueToEnobufs, &m.RetrievalsAbortedDueToErestartsys,\n\t\t\t\t\t&m.RetrievalsFailedDueToEnomem)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr := setFSCacheFields(fields[1:], &m.RetrievalsRequests, &m.RetrievalsWaitingCPU, &m.RetrievalsAbortedDueToObjectDeath)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t}\n\t\tcase \"Stores\":\n\t\t\tif strings.Split(fields[2], \"=\")[0] == \"n\" {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.StoreWriteRequests, &m.StoreSuccessfulRequests,\n\t\t\t\t\t&m.StoreRequestsOnPendingStorage, &m.StoreRequestsRejectedDueToEnobufs, &m.StoreRequestsFailedDueToEnomem)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.StoreRequestsSubmitted, &m.StoreRequestsRunning,\n\t\t\t\t\t&m.StorePagesWithRequestsProcessing, &m.StoreRequestsDeleted, &m.StoreRequestsOverStoreLimit)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t}\n\t\tcase \"VmScan\":\n\t\t\terr := setFSCacheFields(fields[2:], &m.ReleaseRequestsAgainstPagesWithNoPendingStorage,\n\t\t\t\t&m.ReleaseRequestsAgainstPagesStoredByTimeLockGranted, &m.ReleaseRequestsIgnoredDueToInProgressStore,\n\t\t\t\t&m.PageStoresCancelledByReleaseRequests, &m.VmscanWaiting)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\tcase \"Ops\":\n\t\t\tif strings.Split(fields[2], \"=\")[0] == \"pend\" {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.OpsPending, &m.OpsRunning, &m.OpsEnqueued, &m.OpsCancelled, &m.OpsRejected)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr := setFSCacheFields(fields[2:], &m.OpsInitialised, &m.OpsDeferred, &m.OpsReleased, &m.OpsGarbageCollected)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t}\n\t\tcase \"CacheOp:\":\n\t\t\tif strings.Split(fields[1], \"=\")[0] == \"alo\" {\n\t\t\t\terr := setFSCacheFields(fields[1:], &m.CacheopAllocationsinProgress, &m.CacheopLookupObjectInProgress,\n\t\t\t\t\t&m.CacheopLookupCompleteInPorgress, &m.CacheopGrabObjectInProgress)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else if strings.Split(fields[1], \"=\")[0] == \"inv\" {\n\t\t\t\terr := setFSCacheFields(fields[1:], &m.CacheopInvalidations, &m.CacheopUpdateObjectInProgress,\n\t\t\t\t\t&m.CacheopDropObjectInProgress, &m.CacheopPutObjectInProgress, &m.CacheopAttributeChangeInProgress,\n\t\t\t\t\t&m.CacheopSyncCacheInProgress)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr := setFSCacheFields(fields[1:], &m.CacheopReadOrAllocPageInProgress, &m.CacheopReadOrAllocPagesInProgress,\n\t\t\t\t\t&m.CacheopAllocatePageInProgress, &m.CacheopAllocatePagesInProgress, &m.CacheopWritePagesInProgress,\n\t\t\t\t\t&m.CacheopUncachePagesInProgress, &m.CacheopDissociatePagesInProgress)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn &m, err\n\t\t\t\t}\n\t\t\t}\n\t\tcase \"CacheEv:\":\n\t\t\terr := setFSCacheFields(fields[1:], &m.CacheevLookupsAndCreationsRejectedLackSpace, &m.CacheevStaleObjectsDeleted,\n\t\t\t\t&m.CacheevRetiredWhenReliquished, &m.CacheevObjectsCulled)\n\t\t\tif err != nil {\n\t\t\t\treturn &m, err\n\t\t\t}\n\t\t}\n\t}\n\n\treturn &m, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/fs/fs.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage fs\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n)\n\nconst (\n\t// DefaultProcMountPoint is the common mount point of the proc filesystem.\n\tDefaultProcMountPoint = \"/proc\"\n\n\t// DefaultSysMountPoint is the common mount point of the sys filesystem.\n\tDefaultSysMountPoint = \"/sys\"\n\n\t// DefaultConfigfsMountPoint is the common mount point of the configfs.\n\tDefaultConfigfsMountPoint = \"/sys/kernel/config\"\n)\n\n// FS represents a pseudo-filesystem, normally /proc or /sys, which provides an\n// interface to kernel data structures.\ntype FS string\n\n// NewFS returns a new FS mounted under the given mountPoint. It will error\n// if the mount point can't be read.\nfunc NewFS(mountPoint string) (FS, error) {\n\tinfo, err := os.Stat(mountPoint)\n\tif err != nil {\n\t\treturn \"\", fmt.Errorf(\"could not read %q: %w\", mountPoint, err)\n\t}\n\tif !info.IsDir() {\n\t\treturn \"\", fmt.Errorf(\"mount point %q is not a directory\", mountPoint)\n\t}\n\n\treturn FS(mountPoint), nil\n}\n\n// Path appends the given path elements to the filesystem path, adding separators\n// as necessary.\nfunc (fs FS) Path(p ...string) string {\n\treturn filepath.Join(append([]string{string(fs)}, p...)...)\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/util/parse.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage util\n\nimport (\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// ParseUint32s parses a slice of strings into a slice of uint32s.\nfunc ParseUint32s(ss []string) ([]uint32, error) {\n\tus := make([]uint32, 0, len(ss))\n\tfor _, s := range ss {\n\t\tu, err := strconv.ParseUint(s, 10, 32)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tus = append(us, uint32(u))\n\t}\n\n\treturn us, nil\n}\n\n// ParseUint64s parses a slice of strings into a slice of uint64s.\nfunc ParseUint64s(ss []string) ([]uint64, error) {\n\tus := make([]uint64, 0, len(ss))\n\tfor _, s := range ss {\n\t\tu, err := strconv.ParseUint(s, 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tus = append(us, u)\n\t}\n\n\treturn us, nil\n}\n\n// ParsePInt64s parses a slice of strings into a slice of int64 pointers.\nfunc ParsePInt64s(ss []string) ([]*int64, error) {\n\tus := make([]*int64, 0, len(ss))\n\tfor _, s := range ss {\n\t\tu, err := strconv.ParseInt(s, 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tus = append(us, &u)\n\t}\n\n\treturn us, nil\n}\n\n// ReadUintFromFile reads a file and attempts to parse a uint64 from it.\nfunc ReadUintFromFile(path string) (uint64, error) {\n\tdata, err := os.ReadFile(path)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)\n}\n\n// ReadIntFromFile reads a file and attempts to parse a int64 from it.\nfunc ReadIntFromFile(path string) (int64, error) {\n\tdata, err := os.ReadFile(path)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)\n}\n\n// ParseBool parses a string into a boolean pointer.\nfunc ParseBool(b string) *bool {\n\tvar truth bool\n\tswitch b {\n\tcase \"enabled\":\n\t\ttruth = true\n\tcase \"disabled\":\n\t\ttruth = false\n\tdefault:\n\t\treturn nil\n\t}\n\treturn &truth\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/util/readfile.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage util\n\nimport (\n\t\"io\"\n\t\"os\"\n)\n\n// ReadFileNoStat uses io.ReadAll to read contents of entire file.\n// This is similar to os.ReadFile but without the call to os.Stat, because\n// many files in /proc and /sys report incorrect file sizes (either 0 or 4096).\n// Reads a max file size of 1024kB. For files larger than this, a scanner\n// should be used.\nfunc ReadFileNoStat(filename string) ([]byte, error) {\n\tconst maxBufferSize = 1024 * 1024\n\n\tf, err := os.Open(filename)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer f.Close()\n\n\treader := io.LimitReader(f, maxBufferSize)\n\treturn io.ReadAll(reader)\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/util/sysreadfile.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build (linux || darwin) && !appengine\n// +build linux darwin\n// +build !appengine\n\npackage util\n\nimport (\n\t\"bytes\"\n\t\"os\"\n\t\"syscall\"\n)\n\n// SysReadFile is a simplified os.ReadFile that invokes syscall.Read directly.\n// https://github.com/prometheus/node_exporter/pull/728/files\n//\n// Note that this function will not read files larger than 128 bytes.\nfunc SysReadFile(file string) (string, error) {\n\tf, err := os.Open(file)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\tdefer f.Close()\n\n\t// On some machines, hwmon drivers are broken and return EAGAIN. This causes\n\t// Go's os.ReadFile implementation to poll forever.\n\t//\n\t// Since we either want to read data or bail immediately, do the simplest\n\t// possible read using syscall directly.\n\tconst sysFileBufferSize = 128\n\tb := make([]byte, sysFileBufferSize)\n\tn, err := syscall.Read(int(f.Fd()), b)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\n\treturn string(bytes.TrimSpace(b[:n])), nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/util/sysreadfile_compat.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build (linux && appengine) || (!linux && !darwin)\n// +build linux,appengine !linux,!darwin\n\npackage util\n\nimport (\n\t\"fmt\"\n)\n\n// SysReadFile is here implemented as a noop for builds that do not support\n// the read syscall. For example Windows, or Linux on Google App Engine.\nfunc SysReadFile(file string) (string, error) {\n\treturn \"\", fmt.Errorf(\"not supported on this platform\")\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/internal/util/valueparser.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage util\n\nimport (\n\t\"strconv\"\n)\n\n// TODO(mdlayher): util packages are an anti-pattern and this should be moved\n// somewhere else that is more focused in the future.\n\n// A ValueParser enables parsing a single string into a variety of data types\n// in a concise and safe way. The Err method must be invoked after invoking\n// any other methods to ensure a value was successfully parsed.\ntype ValueParser struct {\n\tv string\n\terr error\n}\n\n// NewValueParser creates a ValueParser using the input string.\nfunc NewValueParser(v string) *ValueParser {\n\treturn &ValueParser{v: v}\n}\n\n// Int interprets the underlying value as an int and returns that value.\nfunc (vp *ValueParser) Int() int { return int(vp.int64()) }\n\n// PInt64 interprets the underlying value as an int64 and returns a pointer to\n// that value.\nfunc (vp *ValueParser) PInt64() *int64 {\n\tif vp.err != nil {\n\t\treturn nil\n\t}\n\n\tv := vp.int64()\n\treturn &v\n}\n\n// int64 interprets the underlying value as an int64 and returns that value.\n// TODO: export if/when necessary.\nfunc (vp *ValueParser) int64() int64 {\n\tif vp.err != nil {\n\t\treturn 0\n\t}\n\n\t// A base value of zero makes ParseInt infer the correct base using the\n\t// string's prefix, if any.\n\tconst base = 0\n\tv, err := strconv.ParseInt(vp.v, base, 64)\n\tif err != nil {\n\t\tvp.err = err\n\t\treturn 0\n\t}\n\n\treturn v\n}\n\n// PUInt64 interprets the underlying value as an uint64 and returns a pointer to\n// that value.\nfunc (vp *ValueParser) PUInt64() *uint64 {\n\tif vp.err != nil {\n\t\treturn nil\n\t}\n\n\t// A base value of zero makes ParseInt infer the correct base using the\n\t// string's prefix, if any.\n\tconst base = 0\n\tv, err := strconv.ParseUint(vp.v, base, 64)\n\tif err != nil {\n\t\tvp.err = err\n\t\treturn nil\n\t}\n\n\treturn &v\n}\n\n// Err returns the last error, if any, encountered by the ValueParser.\nfunc (vp *ValueParser) Err() error {\n\treturn vp.err\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/ipvs.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"encoding/hex\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// IPVSStats holds IPVS statistics, as exposed by the kernel in `/proc/net/ip_vs_stats`.\ntype IPVSStats struct {\n\t// Total count of connections.\n\tConnections uint64\n\t// Total incoming packages processed.\n\tIncomingPackets uint64\n\t// Total outgoing packages processed.\n\tOutgoingPackets uint64\n\t// Total incoming traffic.\n\tIncomingBytes uint64\n\t// Total outgoing traffic.\n\tOutgoingBytes uint64\n}\n\n// IPVSBackendStatus holds current metrics of one virtual / real address pair.\ntype IPVSBackendStatus struct {\n\t// The local (virtual) IP address.\n\tLocalAddress net.IP\n\t// The remote (real) IP address.\n\tRemoteAddress net.IP\n\t// The local (virtual) port.\n\tLocalPort uint16\n\t// The remote (real) port.\n\tRemotePort uint16\n\t// The local firewall mark\n\tLocalMark string\n\t// The transport protocol (TCP, UDP).\n\tProto string\n\t// The current number of active connections for this virtual/real address pair.\n\tActiveConn uint64\n\t// The current number of inactive connections for this virtual/real address pair.\n\tInactConn uint64\n\t// The current weight of this virtual/real address pair.\n\tWeight uint64\n}\n\n// IPVSStats reads the IPVS statistics from the specified `proc` filesystem.\nfunc (fs FS) IPVSStats() (IPVSStats, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"net/ip_vs_stats\"))\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\n\treturn parseIPVSStats(bytes.NewReader(data))\n}\n\n// parseIPVSStats performs the actual parsing of `ip_vs_stats`.\nfunc parseIPVSStats(r io.Reader) (IPVSStats, error) {\n\tvar (\n\t\tstatContent []byte\n\t\tstatLines []string\n\t\tstatFields []string\n\t\tstats IPVSStats\n\t)\n\n\tstatContent, err := io.ReadAll(r)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\n\tstatLines = strings.SplitN(string(statContent), \"\\n\", 4)\n\tif len(statLines) != 4 {\n\t\treturn IPVSStats{}, errors.New(\"ip_vs_stats corrupt: too short\")\n\t}\n\n\tstatFields = strings.Fields(statLines[2])\n\tif len(statFields) != 5 {\n\t\treturn IPVSStats{}, errors.New(\"ip_vs_stats corrupt: unexpected number of fields\")\n\t}\n\n\tstats.Connections, err = strconv.ParseUint(statFields[0], 16, 64)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\tstats.IncomingPackets, err = strconv.ParseUint(statFields[1], 16, 64)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\tstats.OutgoingPackets, err = strconv.ParseUint(statFields[2], 16, 64)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\tstats.IncomingBytes, err = strconv.ParseUint(statFields[3], 16, 64)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\tstats.OutgoingBytes, err = strconv.ParseUint(statFields[4], 16, 64)\n\tif err != nil {\n\t\treturn IPVSStats{}, err\n\t}\n\n\treturn stats, nil\n}\n\n// IPVSBackendStatus reads and returns the status of all (virtual,real) server pairs from the specified `proc` filesystem.\nfunc (fs FS) IPVSBackendStatus() ([]IPVSBackendStatus, error) {\n\tfile, err := os.Open(fs.proc.Path(\"net/ip_vs\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer file.Close()\n\n\treturn parseIPVSBackendStatus(file)\n}\n\nfunc parseIPVSBackendStatus(file io.Reader) ([]IPVSBackendStatus, error) {\n\tvar (\n\t\tstatus []IPVSBackendStatus\n\t\tscanner = bufio.NewScanner(file)\n\t\tproto string\n\t\tlocalMark string\n\t\tlocalAddress net.IP\n\t\tlocalPort uint16\n\t\terr error\n\t)\n\n\tfor scanner.Scan() {\n\t\tfields := strings.Fields(scanner.Text())\n\t\tif len(fields) == 0 {\n\t\t\tcontinue\n\t\t}\n\t\tswitch {\n\t\tcase fields[0] == \"IP\" || fields[0] == \"Prot\" || fields[1] == \"RemoteAddress:Port\":\n\t\t\tcontinue\n\t\tcase fields[0] == \"TCP\" || fields[0] == \"UDP\":\n\t\t\tif len(fields) < 2 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tproto = fields[0]\n\t\t\tlocalMark = \"\"\n\t\t\tlocalAddress, localPort, err = parseIPPort(fields[1])\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\tcase fields[0] == \"FWM\":\n\t\t\tif len(fields) < 2 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tproto = fields[0]\n\t\t\tlocalMark = fields[1]\n\t\t\tlocalAddress = nil\n\t\t\tlocalPort = 0\n\t\tcase fields[0] == \"->\":\n\t\t\tif len(fields) < 6 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tremoteAddress, remotePort, err := parseIPPort(fields[1])\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tweight, err := strconv.ParseUint(fields[3], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tactiveConn, err := strconv.ParseUint(fields[4], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tinactConn, err := strconv.ParseUint(fields[5], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tstatus = append(status, IPVSBackendStatus{\n\t\t\t\tLocalAddress: localAddress,\n\t\t\t\tLocalPort: localPort,\n\t\t\t\tLocalMark: localMark,\n\t\t\t\tRemoteAddress: remoteAddress,\n\t\t\t\tRemotePort: remotePort,\n\t\t\t\tProto: proto,\n\t\t\t\tWeight: weight,\n\t\t\t\tActiveConn: activeConn,\n\t\t\t\tInactConn: inactConn,\n\t\t\t})\n\t\t}\n\t}\n\treturn status, nil\n}\n\nfunc parseIPPort(s string) (net.IP, uint16, error) {\n\tvar (\n\t\tip net.IP\n\t\terr error\n\t)\n\n\tswitch len(s) {\n\tcase 13:\n\t\tip, err = hex.DecodeString(s[0:8])\n\t\tif err != nil {\n\t\t\treturn nil, 0, err\n\t\t}\n\tcase 46:\n\t\tip = net.ParseIP(s[1:40])\n\t\tif ip == nil {\n\t\t\treturn nil, 0, fmt.Errorf(\"invalid IPv6 address: %s\", s[1:40])\n\t\t}\n\tdefault:\n\t\treturn nil, 0, fmt.Errorf(\"unexpected IP:Port: %s\", s)\n\t}\n\n\tportString := s[len(s)-4:]\n\tif len(portString) != 4 {\n\t\treturn nil, 0, fmt.Errorf(\"unexpected port string format: %s\", portString)\n\t}\n\tport, err := strconv.ParseUint(portString, 16, 16)\n\tif err != nil {\n\t\treturn nil, 0, err\n\t}\n\n\treturn ip, uint16(port), nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/kernel_random.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows\n// +build !windows\n\npackage procfs\n\nimport (\n\t\"os\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// KernelRandom contains information about to the kernel's random number generator.\ntype KernelRandom struct {\n\t// EntropyAvaliable gives the available entropy, in bits.\n\tEntropyAvaliable *uint64\n\t// PoolSize gives the size of the entropy pool, in bits.\n\tPoolSize *uint64\n\t// URandomMinReseedSeconds is the number of seconds after which the DRNG will be reseeded.\n\tURandomMinReseedSeconds *uint64\n\t// WriteWakeupThreshold the number of bits of entropy below which we wake up processes\n\t// that do a select(2) or poll(2) for write access to /dev/random.\n\tWriteWakeupThreshold *uint64\n\t// ReadWakeupThreshold is the number of bits of entropy required for waking up processes that sleep\n\t// waiting for entropy from /dev/random.\n\tReadWakeupThreshold *uint64\n}\n\n// KernelRandom returns values from /proc/sys/kernel/random.\nfunc (fs FS) KernelRandom() (KernelRandom, error) {\n\trandom := KernelRandom{}\n\n\tfor file, p := range map[string]**uint64{\n\t\t\"entropy_avail\": &random.EntropyAvaliable,\n\t\t\"poolsize\": &random.PoolSize,\n\t\t\"urandom_min_reseed_secs\": &random.URandomMinReseedSeconds,\n\t\t\"write_wakeup_threshold\": &random.WriteWakeupThreshold,\n\t\t\"read_wakeup_threshold\": &random.ReadWakeupThreshold,\n\t} {\n\t\tval, err := util.ReadUintFromFile(fs.proc.Path(\"sys\", \"kernel\", \"random\", file))\n\t\tif os.IsNotExist(err) {\n\t\t\tcontinue\n\t\t}\n\t\tif err != nil {\n\t\t\treturn random, err\n\t\t}\n\t\t*p = &val\n\t}\n\n\treturn random, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/loadavg.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// LoadAvg represents an entry in /proc/loadavg.\ntype LoadAvg struct {\n\tLoad1 float64\n\tLoad5 float64\n\tLoad15 float64\n}\n\n// LoadAvg returns loadavg from /proc.\nfunc (fs FS) LoadAvg() (*LoadAvg, error) {\n\tpath := fs.proc.Path(\"loadavg\")\n\n\tdata, err := util.ReadFileNoStat(path)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseLoad(data)\n}\n\n// Parse /proc loadavg and return 1m, 5m and 15m.\nfunc parseLoad(loadavgBytes []byte) (*LoadAvg, error) {\n\tloads := make([]float64, 3)\n\tparts := strings.Fields(string(loadavgBytes))\n\tif len(parts) < 3 {\n\t\treturn nil, fmt.Errorf(\"malformed loadavg line: too few fields in loadavg string: %q\", string(loadavgBytes))\n\t}\n\n\tvar err error\n\tfor i, load := range parts[0:3] {\n\t\tloads[i], err = strconv.ParseFloat(load, 64)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"could not parse load %q: %w\", load, err)\n\t\t}\n\t}\n\treturn &LoadAvg{\n\t\tLoad1: loads[0],\n\t\tLoad5: loads[1],\n\t\tLoad15: loads[2],\n\t}, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/mdstat.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n)\n\nvar (\n\tstatusLineRE = regexp.MustCompile(`(\\d+) blocks .*\\[(\\d+)/(\\d+)\\] \\[([U_]+)\\]`)\n\trecoveryLineBlocksRE = regexp.MustCompile(`\\((\\d+)/\\d+\\)`)\n\trecoveryLinePctRE = regexp.MustCompile(`= (.+)%`)\n\trecoveryLineFinishRE = regexp.MustCompile(`finish=(.+)min`)\n\trecoveryLineSpeedRE = regexp.MustCompile(`speed=(.+)[A-Z]`)\n\tcomponentDeviceRE = regexp.MustCompile(`(.*)\\[\\d+\\]`)\n)\n\n// MDStat holds info parsed from /proc/mdstat.\ntype MDStat struct {\n\t// Name of the device.\n\tName string\n\t// activity-state of the device.\n\tActivityState string\n\t// Number of active disks.\n\tDisksActive int64\n\t// Total number of disks the device requires.\n\tDisksTotal int64\n\t// Number of failed disks.\n\tDisksFailed int64\n\t// Number of \"down\" disks. (the _ indicator in the status line)\n\tDisksDown int64\n\t// Spare disks in the device.\n\tDisksSpare int64\n\t// Number of blocks the device holds.\n\tBlocksTotal int64\n\t// Number of blocks on the device that are in sync.\n\tBlocksSynced int64\n\t// progress percentage of current sync\n\tBlocksSyncedPct float64\n\t// estimated finishing time for current sync (in minutes)\n\tBlocksSyncedFinishTime float64\n\t// current sync speed (in Kilobytes/sec)\n\tBlocksSyncedSpeed float64\n\t// Name of md component devices\n\tDevices []string\n}\n\n// MDStat parses an mdstat-file (/proc/mdstat) and returns a slice of\n// structs containing the relevant info. More information available here:\n// https://raid.wiki.kernel.org/index.php/Mdstat\nfunc (fs FS) MDStat() ([]MDStat, error) {\n\tdata, err := os.ReadFile(fs.proc.Path(\"mdstat\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tmdstat, err := parseMDStat(data)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error parsing mdstat %q: %w\", fs.proc.Path(\"mdstat\"), err)\n\t}\n\treturn mdstat, nil\n}\n\n// parseMDStat parses data from mdstat file (/proc/mdstat) and returns a slice of\n// structs containing the relevant info.\nfunc parseMDStat(mdStatData []byte) ([]MDStat, error) {\n\tmdStats := []MDStat{}\n\tlines := strings.Split(string(mdStatData), \"\\n\")\n\n\tfor i, line := range lines {\n\t\tif strings.TrimSpace(line) == \"\" || line[0] == ' ' ||\n\t\t\tstrings.HasPrefix(line, \"Personalities\") ||\n\t\t\tstrings.HasPrefix(line, \"unused\") {\n\t\t\tcontinue\n\t\t}\n\n\t\tdeviceFields := strings.Fields(line)\n\t\tif len(deviceFields) < 3 {\n\t\t\treturn nil, fmt.Errorf(\"not enough fields in mdline (expected at least 3): %s\", line)\n\t\t}\n\t\tmdName := deviceFields[0] // mdx\n\t\tstate := deviceFields[2] // active or inactive\n\n\t\tif len(lines) <= i+3 {\n\t\t\treturn nil, fmt.Errorf(\"error parsing %q: too few lines for md device\", mdName)\n\t\t}\n\n\t\t// Failed disks have the suffix (F) & Spare disks have the suffix (S).\n\t\tfail := int64(strings.Count(line, \"(F)\"))\n\t\tspare := int64(strings.Count(line, \"(S)\"))\n\t\tactive, total, down, size, err := evalStatusLine(lines[i], lines[i+1])\n\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"error parsing md device lines: %w\", err)\n\t\t}\n\n\t\tsyncLineIdx := i + 2\n\t\tif strings.Contains(lines[i+2], \"bitmap\") { // skip bitmap line\n\t\t\tsyncLineIdx++\n\t\t}\n\n\t\t// If device is syncing at the moment, get the number of currently\n\t\t// synced bytes, otherwise that number equals the size of the device.\n\t\tsyncedBlocks := size\n\t\tspeed := float64(0)\n\t\tfinish := float64(0)\n\t\tpct := float64(0)\n\t\trecovering := strings.Contains(lines[syncLineIdx], \"recovery\")\n\t\tresyncing := strings.Contains(lines[syncLineIdx], \"resync\")\n\t\tchecking := strings.Contains(lines[syncLineIdx], \"check\")\n\n\t\t// Append recovery and resyncing state info.\n\t\tif recovering || resyncing || checking {\n\t\t\tif recovering {\n\t\t\t\tstate = \"recovering\"\n\t\t\t} else if checking {\n\t\t\t\tstate = \"checking\"\n\t\t\t} else {\n\t\t\t\tstate = \"resyncing\"\n\t\t\t}\n\n\t\t\t// Handle case when resync=PENDING or resync=DELAYED.\n\t\t\tif strings.Contains(lines[syncLineIdx], \"PENDING\") ||\n\t\t\t\tstrings.Contains(lines[syncLineIdx], \"DELAYED\") {\n\t\t\t\tsyncedBlocks = 0\n\t\t\t} else {\n\t\t\t\tsyncedBlocks, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx])\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn nil, fmt.Errorf(\"error parsing sync line in md device %q: %w\", mdName, err)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tmdStats = append(mdStats, MDStat{\n\t\t\tName: mdName,\n\t\t\tActivityState: state,\n\t\t\tDisksActive: active,\n\t\t\tDisksFailed: fail,\n\t\t\tDisksDown: down,\n\t\t\tDisksSpare: spare,\n\t\t\tDisksTotal: total,\n\t\t\tBlocksTotal: size,\n\t\t\tBlocksSynced: syncedBlocks,\n\t\t\tBlocksSyncedPct: pct,\n\t\t\tBlocksSyncedFinishTime: finish,\n\t\t\tBlocksSyncedSpeed: speed,\n\t\t\tDevices: evalComponentDevices(deviceFields),\n\t\t})\n\t}\n\n\treturn mdStats, nil\n}\n\nfunc evalStatusLine(deviceLine, statusLine string) (active, total, down, size int64, err error) {\n\tstatusFields := strings.Fields(statusLine)\n\tif len(statusFields) < 1 {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"unexpected statusLine %q\", statusLine)\n\t}\n\n\tsizeStr := statusFields[0]\n\tsize, err = strconv.ParseInt(sizeStr, 10, 64)\n\tif err != nil {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"unexpected statusLine %q: %w\", statusLine, err)\n\t}\n\n\tif strings.Contains(deviceLine, \"raid0\") || strings.Contains(deviceLine, \"linear\") {\n\t\t// In the device deviceLine, only disks have a number associated with them in [].\n\t\ttotal = int64(strings.Count(deviceLine, \"[\"))\n\t\treturn total, total, 0, size, nil\n\t}\n\n\tif strings.Contains(deviceLine, \"inactive\") {\n\t\treturn 0, 0, 0, size, nil\n\t}\n\n\tmatches := statusLineRE.FindStringSubmatch(statusLine)\n\tif len(matches) != 5 {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"couldn't find all the substring matches: %s\", statusLine)\n\t}\n\n\ttotal, err = strconv.ParseInt(matches[2], 10, 64)\n\tif err != nil {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"unexpected statusLine %q: %w\", statusLine, err)\n\t}\n\n\tactive, err = strconv.ParseInt(matches[3], 10, 64)\n\tif err != nil {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"unexpected statusLine %q: %w\", statusLine, err)\n\t}\n\tdown = int64(strings.Count(matches[4], \"_\"))\n\n\treturn active, total, down, size, nil\n}\n\nfunc evalRecoveryLine(recoveryLine string) (syncedBlocks int64, pct float64, finish float64, speed float64, err error) {\n\tmatches := recoveryLineBlocksRE.FindStringSubmatch(recoveryLine)\n\tif len(matches) != 2 {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"unexpected recoveryLine: %s\", recoveryLine)\n\t}\n\n\tsyncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)\n\tif err != nil {\n\t\treturn 0, 0, 0, 0, fmt.Errorf(\"error parsing int from recoveryLine %q: %w\", recoveryLine, err)\n\t}\n\n\t// Get percentage complete\n\tmatches = recoveryLinePctRE.FindStringSubmatch(recoveryLine)\n\tif len(matches) != 2 {\n\t\treturn syncedBlocks, 0, 0, 0, fmt.Errorf(\"unexpected recoveryLine matching percentage: %s\", recoveryLine)\n\t}\n\tpct, err = strconv.ParseFloat(strings.TrimSpace(matches[1]), 64)\n\tif err != nil {\n\t\treturn syncedBlocks, 0, 0, 0, fmt.Errorf(\"error parsing float from recoveryLine %q: %w\", recoveryLine, err)\n\t}\n\n\t// Get time expected left to complete\n\tmatches = recoveryLineFinishRE.FindStringSubmatch(recoveryLine)\n\tif len(matches) != 2 {\n\t\treturn syncedBlocks, pct, 0, 0, fmt.Errorf(\"unexpected recoveryLine matching est. finish time: %s\", recoveryLine)\n\t}\n\tfinish, err = strconv.ParseFloat(matches[1], 64)\n\tif err != nil {\n\t\treturn syncedBlocks, pct, 0, 0, fmt.Errorf(\"error parsing float from recoveryLine %q: %w\", recoveryLine, err)\n\t}\n\n\t// Get recovery speed\n\tmatches = recoveryLineSpeedRE.FindStringSubmatch(recoveryLine)\n\tif len(matches) != 2 {\n\t\treturn syncedBlocks, pct, finish, 0, fmt.Errorf(\"unexpected recoveryLine matching speed: %s\", recoveryLine)\n\t}\n\tspeed, err = strconv.ParseFloat(matches[1], 64)\n\tif err != nil {\n\t\treturn syncedBlocks, pct, finish, 0, fmt.Errorf(\"error parsing float from recoveryLine %q: %w\", recoveryLine, err)\n\t}\n\n\treturn syncedBlocks, pct, finish, speed, nil\n}\n\nfunc evalComponentDevices(deviceFields []string) []string {\n\tmdComponentDevices := make([]string, 0)\n\tif len(deviceFields) > 3 {\n\t\tfor _, field := range deviceFields[4:] {\n\t\t\tmatch := componentDeviceRE.FindStringSubmatch(field)\n\t\t\tif match == nil {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tmdComponentDevices = append(mdComponentDevices, match[1])\n\t\t}\n\t}\n\n\treturn mdComponentDevices\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/meminfo.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Meminfo represents memory statistics.\ntype Meminfo struct {\n\t// Total usable ram (i.e. physical ram minus a few reserved\n\t// bits and the kernel binary code)\n\tMemTotal *uint64\n\t// The sum of LowFree+HighFree\n\tMemFree *uint64\n\t// An estimate of how much memory is available for starting\n\t// new applications, without swapping. Calculated from\n\t// MemFree, SReclaimable, the size of the file LRU lists, and\n\t// the low watermarks in each zone. The estimate takes into\n\t// account that the system needs some page cache to function\n\t// well, and that not all reclaimable slab will be\n\t// reclaimable, due to items being in use. The impact of those\n\t// factors will vary from system to system.\n\tMemAvailable *uint64\n\t// Relatively temporary storage for raw disk blocks shouldn't\n\t// get tremendously large (20MB or so)\n\tBuffers *uint64\n\tCached *uint64\n\t// Memory that once was swapped out, is swapped back in but\n\t// still also is in the swapfile (if memory is needed it\n\t// doesn't need to be swapped out AGAIN because it is already\n\t// in the swapfile. This saves I/O)\n\tSwapCached *uint64\n\t// Memory that has been used more recently and usually not\n\t// reclaimed unless absolutely necessary.\n\tActive *uint64\n\t// Memory which has been less recently used. It is more\n\t// eligible to be reclaimed for other purposes\n\tInactive *uint64\n\tActiveAnon *uint64\n\tInactiveAnon *uint64\n\tActiveFile *uint64\n\tInactiveFile *uint64\n\tUnevictable *uint64\n\tMlocked *uint64\n\t// total amount of swap space available\n\tSwapTotal *uint64\n\t// Memory which has been evicted from RAM, and is temporarily\n\t// on the disk\n\tSwapFree *uint64\n\t// Memory which is waiting to get written back to the disk\n\tDirty *uint64\n\t// Memory which is actively being written back to the disk\n\tWriteback *uint64\n\t// Non-file backed pages mapped into userspace page tables\n\tAnonPages *uint64\n\t// files which have been mapped, such as libraries\n\tMapped *uint64\n\tShmem *uint64\n\t// in-kernel data structures cache\n\tSlab *uint64\n\t// Part of Slab, that might be reclaimed, such as caches\n\tSReclaimable *uint64\n\t// Part of Slab, that cannot be reclaimed on memory pressure\n\tSUnreclaim *uint64\n\tKernelStack *uint64\n\t// amount of memory dedicated to the lowest level of page\n\t// tables.\n\tPageTables *uint64\n\t// NFS pages sent to the server, but not yet committed to\n\t// stable storage\n\tNFSUnstable *uint64\n\t// Memory used for block device \"bounce buffers\"\n\tBounce *uint64\n\t// Memory used by FUSE for temporary writeback buffers\n\tWritebackTmp *uint64\n\t// Based on the overcommit ratio ('vm.overcommit_ratio'),\n\t// this is the total amount of memory currently available to\n\t// be allocated on the system. This limit is only adhered to\n\t// if strict overcommit accounting is enabled (mode 2 in\n\t// 'vm.overcommit_memory').\n\t// The CommitLimit is calculated with the following formula:\n\t// CommitLimit = ([total RAM pages] - [total huge TLB pages]) *\n\t// overcommit_ratio / 100 + [total swap pages]\n\t// For example, on a system with 1G of physical RAM and 7G\n\t// of swap with a `vm.overcommit_ratio` of 30 it would\n\t// yield a CommitLimit of 7.3G.\n\t// For more details, see the memory overcommit documentation\n\t// in vm/overcommit-accounting.\n\tCommitLimit *uint64\n\t// The amount of memory presently allocated on the system.\n\t// The committed memory is a sum of all of the memory which\n\t// has been allocated by processes, even if it has not been\n\t// \"used\" by them as of yet. A process which malloc()'s 1G\n\t// of memory, but only touches 300M of it will show up as\n\t// using 1G. This 1G is memory which has been \"committed\" to\n\t// by the VM and can be used at any time by the allocating\n\t// application. With strict overcommit enabled on the system\n\t// (mode 2 in 'vm.overcommit_memory'),allocations which would\n\t// exceed the CommitLimit (detailed above) will not be permitted.\n\t// This is useful if one needs to guarantee that processes will\n\t// not fail due to lack of memory once that memory has been\n\t// successfully allocated.\n\tCommittedAS *uint64\n\t// total size of vmalloc memory area\n\tVmallocTotal *uint64\n\t// amount of vmalloc area which is used\n\tVmallocUsed *uint64\n\t// largest contiguous block of vmalloc area which is free\n\tVmallocChunk *uint64\n\tHardwareCorrupted *uint64\n\tAnonHugePages *uint64\n\tShmemHugePages *uint64\n\tShmemPmdMapped *uint64\n\tCmaTotal *uint64\n\tCmaFree *uint64\n\tHugePagesTotal *uint64\n\tHugePagesFree *uint64\n\tHugePagesRsvd *uint64\n\tHugePagesSurp *uint64\n\tHugepagesize *uint64\n\tDirectMap4k *uint64\n\tDirectMap2M *uint64\n\tDirectMap1G *uint64\n}\n\n// Meminfo returns an information about current kernel/system memory statistics.\n// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt\nfunc (fs FS) Meminfo() (Meminfo, error) {\n\tb, err := util.ReadFileNoStat(fs.proc.Path(\"meminfo\"))\n\tif err != nil {\n\t\treturn Meminfo{}, err\n\t}\n\n\tm, err := parseMemInfo(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn Meminfo{}, fmt.Errorf(\"failed to parse meminfo: %w\", err)\n\t}\n\n\treturn *m, nil\n}\n\nfunc parseMemInfo(r io.Reader) (*Meminfo, error) {\n\tvar m Meminfo\n\ts := bufio.NewScanner(r)\n\tfor s.Scan() {\n\t\t// Each line has at least a name and value; we ignore the unit.\n\t\tfields := strings.Fields(s.Text())\n\t\tif len(fields) < 2 {\n\t\t\treturn nil, fmt.Errorf(\"malformed meminfo line: %q\", s.Text())\n\t\t}\n\n\t\tv, err := strconv.ParseUint(fields[1], 0, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tswitch fields[0] {\n\t\tcase \"MemTotal:\":\n\t\t\tm.MemTotal = &v\n\t\tcase \"MemFree:\":\n\t\t\tm.MemFree = &v\n\t\tcase \"MemAvailable:\":\n\t\t\tm.MemAvailable = &v\n\t\tcase \"Buffers:\":\n\t\t\tm.Buffers = &v\n\t\tcase \"Cached:\":\n\t\t\tm.Cached = &v\n\t\tcase \"SwapCached:\":\n\t\t\tm.SwapCached = &v\n\t\tcase \"Active:\":\n\t\t\tm.Active = &v\n\t\tcase \"Inactive:\":\n\t\t\tm.Inactive = &v\n\t\tcase \"Active(anon):\":\n\t\t\tm.ActiveAnon = &v\n\t\tcase \"Inactive(anon):\":\n\t\t\tm.InactiveAnon = &v\n\t\tcase \"Active(file):\":\n\t\t\tm.ActiveFile = &v\n\t\tcase \"Inactive(file):\":\n\t\t\tm.InactiveFile = &v\n\t\tcase \"Unevictable:\":\n\t\t\tm.Unevictable = &v\n\t\tcase \"Mlocked:\":\n\t\t\tm.Mlocked = &v\n\t\tcase \"SwapTotal:\":\n\t\t\tm.SwapTotal = &v\n\t\tcase \"SwapFree:\":\n\t\t\tm.SwapFree = &v\n\t\tcase \"Dirty:\":\n\t\t\tm.Dirty = &v\n\t\tcase \"Writeback:\":\n\t\t\tm.Writeback = &v\n\t\tcase \"AnonPages:\":\n\t\t\tm.AnonPages = &v\n\t\tcase \"Mapped:\":\n\t\t\tm.Mapped = &v\n\t\tcase \"Shmem:\":\n\t\t\tm.Shmem = &v\n\t\tcase \"Slab:\":\n\t\t\tm.Slab = &v\n\t\tcase \"SReclaimable:\":\n\t\t\tm.SReclaimable = &v\n\t\tcase \"SUnreclaim:\":\n\t\t\tm.SUnreclaim = &v\n\t\tcase \"KernelStack:\":\n\t\t\tm.KernelStack = &v\n\t\tcase \"PageTables:\":\n\t\t\tm.PageTables = &v\n\t\tcase \"NFS_Unstable:\":\n\t\t\tm.NFSUnstable = &v\n\t\tcase \"Bounce:\":\n\t\t\tm.Bounce = &v\n\t\tcase \"WritebackTmp:\":\n\t\t\tm.WritebackTmp = &v\n\t\tcase \"CommitLimit:\":\n\t\t\tm.CommitLimit = &v\n\t\tcase \"Committed_AS:\":\n\t\t\tm.CommittedAS = &v\n\t\tcase \"VmallocTotal:\":\n\t\t\tm.VmallocTotal = &v\n\t\tcase \"VmallocUsed:\":\n\t\t\tm.VmallocUsed = &v\n\t\tcase \"VmallocChunk:\":\n\t\t\tm.VmallocChunk = &v\n\t\tcase \"HardwareCorrupted:\":\n\t\t\tm.HardwareCorrupted = &v\n\t\tcase \"AnonHugePages:\":\n\t\t\tm.AnonHugePages = &v\n\t\tcase \"ShmemHugePages:\":\n\t\t\tm.ShmemHugePages = &v\n\t\tcase \"ShmemPmdMapped:\":\n\t\t\tm.ShmemPmdMapped = &v\n\t\tcase \"CmaTotal:\":\n\t\t\tm.CmaTotal = &v\n\t\tcase \"CmaFree:\":\n\t\t\tm.CmaFree = &v\n\t\tcase \"HugePages_Total:\":\n\t\t\tm.HugePagesTotal = &v\n\t\tcase \"HugePages_Free:\":\n\t\t\tm.HugePagesFree = &v\n\t\tcase \"HugePages_Rsvd:\":\n\t\t\tm.HugePagesRsvd = &v\n\t\tcase \"HugePages_Surp:\":\n\t\t\tm.HugePagesSurp = &v\n\t\tcase \"Hugepagesize:\":\n\t\t\tm.Hugepagesize = &v\n\t\tcase \"DirectMap4k:\":\n\t\t\tm.DirectMap4k = &v\n\t\tcase \"DirectMap2M:\":\n\t\t\tm.DirectMap2M = &v\n\t\tcase \"DirectMap1G:\":\n\t\t\tm.DirectMap1G = &v\n\t\t}\n\t}\n\n\treturn &m, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/mountinfo.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// A MountInfo is a type that describes the details, options\n// for each mount, parsed from /proc/self/mountinfo.\n// The fields described in each entry of /proc/self/mountinfo\n// is described in the following man page.\n// http://man7.org/linux/man-pages/man5/proc.5.html\ntype MountInfo struct {\n\t// Unique ID for the mount\n\tMountID int\n\t// The ID of the parent mount\n\tParentID int\n\t// The value of `st_dev` for the files on this FS\n\tMajorMinorVer string\n\t// The pathname of the directory in the FS that forms\n\t// the root for this mount\n\tRoot string\n\t// The pathname of the mount point relative to the root\n\tMountPoint string\n\t// Mount options\n\tOptions map[string]string\n\t// Zero or more optional fields\n\tOptionalFields map[string]string\n\t// The Filesystem type\n\tFSType string\n\t// FS specific information or \"none\"\n\tSource string\n\t// Superblock options\n\tSuperOptions map[string]string\n}\n\n// Reads each line of the mountinfo file, and returns a list of formatted MountInfo structs.\nfunc parseMountInfo(info []byte) ([]*MountInfo, error) {\n\tmounts := []*MountInfo{}\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\tfor scanner.Scan() {\n\t\tmountString := scanner.Text()\n\t\tparsedMounts, err := parseMountInfoString(mountString)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tmounts = append(mounts, parsedMounts)\n\t}\n\n\terr := scanner.Err()\n\treturn mounts, err\n}\n\n// Parses a mountinfo file line, and converts it to a MountInfo struct.\n// An important check here is to see if the hyphen separator, as if it does not exist,\n// it means that the line is malformed.\nfunc parseMountInfoString(mountString string) (*MountInfo, error) {\n\tvar err error\n\n\tmountInfo := strings.Split(mountString, \" \")\n\tmountInfoLength := len(mountInfo)\n\tif mountInfoLength < 10 {\n\t\treturn nil, fmt.Errorf(\"couldn't find enough fields in mount string: %s\", mountString)\n\t}\n\n\tif mountInfo[mountInfoLength-4] != \"-\" {\n\t\treturn nil, fmt.Errorf(\"couldn't find separator in expected field: %s\", mountInfo[mountInfoLength-4])\n\t}\n\n\tmount := &MountInfo{\n\t\tMajorMinorVer: mountInfo[2],\n\t\tRoot: mountInfo[3],\n\t\tMountPoint: mountInfo[4],\n\t\tOptions: mountOptionsParser(mountInfo[5]),\n\t\tOptionalFields: nil,\n\t\tFSType: mountInfo[mountInfoLength-3],\n\t\tSource: mountInfo[mountInfoLength-2],\n\t\tSuperOptions: mountOptionsParser(mountInfo[mountInfoLength-1]),\n\t}\n\n\tmount.MountID, err = strconv.Atoi(mountInfo[0])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse mount ID\")\n\t}\n\tmount.ParentID, err = strconv.Atoi(mountInfo[1])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse parent ID\")\n\t}\n\t// Has optional fields, which is a space separated list of values.\n\t// Example: shared:2 master:7\n\tif mountInfo[6] != \"\" {\n\t\tmount.OptionalFields, err = mountOptionsParseOptionalFields(mountInfo[6 : mountInfoLength-4])\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\treturn mount, nil\n}\n\n// mountOptionsIsValidField checks a string against a valid list of optional fields keys.\nfunc mountOptionsIsValidField(s string) bool {\n\tswitch s {\n\tcase\n\t\t\"shared\",\n\t\t\"master\",\n\t\t\"propagate_from\",\n\t\t\"unbindable\":\n\t\treturn true\n\t}\n\treturn false\n}\n\n// mountOptionsParseOptionalFields parses a list of optional fields strings into a double map of strings.\nfunc mountOptionsParseOptionalFields(o []string) (map[string]string, error) {\n\toptionalFields := make(map[string]string)\n\tfor _, field := range o {\n\t\toptionSplit := strings.SplitN(field, \":\", 2)\n\t\tvalue := \"\"\n\t\tif len(optionSplit) == 2 {\n\t\t\tvalue = optionSplit[1]\n\t\t}\n\t\tif mountOptionsIsValidField(optionSplit[0]) {\n\t\t\toptionalFields[optionSplit[0]] = value\n\t\t}\n\t}\n\treturn optionalFields, nil\n}\n\n// mountOptionsParser parses the mount options, superblock options.\nfunc mountOptionsParser(mountOptions string) map[string]string {\n\topts := make(map[string]string)\n\toptions := strings.Split(mountOptions, \",\")\n\tfor _, opt := range options {\n\t\tsplitOption := strings.Split(opt, \"=\")\n\t\tif len(splitOption) < 2 {\n\t\t\tkey := splitOption[0]\n\t\t\topts[key] = \"\"\n\t\t} else {\n\t\t\tkey, value := splitOption[0], splitOption[1]\n\t\t\topts[key] = value\n\t\t}\n\t}\n\treturn opts\n}\n\n// GetMounts retrieves mountinfo information from `/proc/self/mountinfo`.\nfunc GetMounts() ([]*MountInfo, error) {\n\tdata, err := util.ReadFileNoStat(\"/proc/self/mountinfo\")\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseMountInfo(data)\n}\n\n// GetProcMounts retrieves mountinfo information from a processes' `/proc//mountinfo`.\nfunc GetProcMounts(pid int) ([]*MountInfo, error) {\n\tdata, err := util.ReadFileNoStat(fmt.Sprintf(\"/proc/%d/mountinfo\", pid))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseMountInfo(data)\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/mountstats.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\n// While implementing parsing of /proc/[pid]/mountstats, this blog was used\n// heavily as a reference:\n// https://utcc.utoronto.ca/~cks/space/blog/linux/NFSMountstatsIndex\n//\n// Special thanks to Chris Siebenmann for all of his posts explaining the\n// various statistics available for NFS.\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n)\n\n// Constants shared between multiple functions.\nconst (\n\tdeviceEntryLen = 8\n\n\tfieldBytesLen = 8\n\tfieldEventsLen = 27\n\n\tstatVersion10 = \"1.0\"\n\tstatVersion11 = \"1.1\"\n\n\tfieldTransport10TCPLen = 10\n\tfieldTransport10UDPLen = 7\n\n\tfieldTransport11TCPLen = 13\n\tfieldTransport11UDPLen = 10\n)\n\n// A Mount is a device mount parsed from /proc/[pid]/mountstats.\ntype Mount struct {\n\t// Name of the device.\n\tDevice string\n\t// The mount point of the device.\n\tMount string\n\t// The filesystem type used by the device.\n\tType string\n\t// If available additional statistics related to this Mount.\n\t// Use a type assertion to determine if additional statistics are available.\n\tStats MountStats\n}\n\n// A MountStats is a type which contains detailed statistics for a specific\n// type of Mount.\ntype MountStats interface {\n\tmountStats()\n}\n\n// A MountStatsNFS is a MountStats implementation for NFSv3 and v4 mounts.\ntype MountStatsNFS struct {\n\t// The version of statistics provided.\n\tStatVersion string\n\t// The mount options of the NFS mount.\n\tOpts map[string]string\n\t// The age of the NFS mount.\n\tAge time.Duration\n\t// Statistics related to byte counters for various operations.\n\tBytes NFSBytesStats\n\t// Statistics related to various NFS event occurrences.\n\tEvents NFSEventsStats\n\t// Statistics broken down by filesystem operation.\n\tOperations []NFSOperationStats\n\t// Statistics about the NFS RPC transport.\n\tTransport NFSTransportStats\n}\n\n// mountStats implements MountStats.\nfunc (m MountStatsNFS) mountStats() {}\n\n// A NFSBytesStats contains statistics about the number of bytes read and written\n// by an NFS client to and from an NFS server.\ntype NFSBytesStats struct {\n\t// Number of bytes read using the read() syscall.\n\tRead uint64\n\t// Number of bytes written using the write() syscall.\n\tWrite uint64\n\t// Number of bytes read using the read() syscall in O_DIRECT mode.\n\tDirectRead uint64\n\t// Number of bytes written using the write() syscall in O_DIRECT mode.\n\tDirectWrite uint64\n\t// Number of bytes read from the NFS server, in total.\n\tReadTotal uint64\n\t// Number of bytes written to the NFS server, in total.\n\tWriteTotal uint64\n\t// Number of pages read directly via mmap()'d files.\n\tReadPages uint64\n\t// Number of pages written directly via mmap()'d files.\n\tWritePages uint64\n}\n\n// A NFSEventsStats contains statistics about NFS event occurrences.\ntype NFSEventsStats struct {\n\t// Number of times cached inode attributes are re-validated from the server.\n\tInodeRevalidate uint64\n\t// Number of times cached dentry nodes are re-validated from the server.\n\tDnodeRevalidate uint64\n\t// Number of times an inode cache is cleared.\n\tDataInvalidate uint64\n\t// Number of times cached inode attributes are invalidated.\n\tAttributeInvalidate uint64\n\t// Number of times files or directories have been open()'d.\n\tVFSOpen uint64\n\t// Number of times a directory lookup has occurred.\n\tVFSLookup uint64\n\t// Number of times permissions have been checked.\n\tVFSAccess uint64\n\t// Number of updates (and potential writes) to pages.\n\tVFSUpdatePage uint64\n\t// Number of pages read directly via mmap()'d files.\n\tVFSReadPage uint64\n\t// Number of times a group of pages have been read.\n\tVFSReadPages uint64\n\t// Number of pages written directly via mmap()'d files.\n\tVFSWritePage uint64\n\t// Number of times a group of pages have been written.\n\tVFSWritePages uint64\n\t// Number of times directory entries have been read with getdents().\n\tVFSGetdents uint64\n\t// Number of times attributes have been set on inodes.\n\tVFSSetattr uint64\n\t// Number of pending writes that have been forcefully flushed to the server.\n\tVFSFlush uint64\n\t// Number of times fsync() has been called on directories and files.\n\tVFSFsync uint64\n\t// Number of times locking has been attempted on a file.\n\tVFSLock uint64\n\t// Number of times files have been closed and released.\n\tVFSFileRelease uint64\n\t// Unknown. Possibly unused.\n\tCongestionWait uint64\n\t// Number of times files have been truncated.\n\tTruncation uint64\n\t// Number of times a file has been grown due to writes beyond its existing end.\n\tWriteExtension uint64\n\t// Number of times a file was removed while still open by another process.\n\tSillyRename uint64\n\t// Number of times the NFS server gave less data than expected while reading.\n\tShortRead uint64\n\t// Number of times the NFS server wrote less data than expected while writing.\n\tShortWrite uint64\n\t// Number of times the NFS server indicated EJUKEBOX; retrieving data from\n\t// offline storage.\n\tJukeboxDelay uint64\n\t// Number of NFS v4.1+ pNFS reads.\n\tPNFSRead uint64\n\t// Number of NFS v4.1+ pNFS writes.\n\tPNFSWrite uint64\n}\n\n// A NFSOperationStats contains statistics for a single operation.\ntype NFSOperationStats struct {\n\t// The name of the operation.\n\tOperation string\n\t// Number of requests performed for this operation.\n\tRequests uint64\n\t// Number of times an actual RPC request has been transmitted for this operation.\n\tTransmissions uint64\n\t// Number of times a request has had a major timeout.\n\tMajorTimeouts uint64\n\t// Number of bytes sent for this operation, including RPC headers and payload.\n\tBytesSent uint64\n\t// Number of bytes received for this operation, including RPC headers and payload.\n\tBytesReceived uint64\n\t// Duration all requests spent queued for transmission before they were sent.\n\tCumulativeQueueMilliseconds uint64\n\t// Duration it took to get a reply back after the request was transmitted.\n\tCumulativeTotalResponseMilliseconds uint64\n\t// Duration from when a request was enqueued to when it was completely handled.\n\tCumulativeTotalRequestMilliseconds uint64\n\t// The count of operations that complete with tk_status < 0. These statuses usually indicate error conditions.\n\tErrors uint64\n}\n\n// A NFSTransportStats contains statistics for the NFS mount RPC requests and\n// responses.\ntype NFSTransportStats struct {\n\t// The transport protocol used for the NFS mount.\n\tProtocol string\n\t// The local port used for the NFS mount.\n\tPort uint64\n\t// Number of times the client has had to establish a connection from scratch\n\t// to the NFS server.\n\tBind uint64\n\t// Number of times the client has made a TCP connection to the NFS server.\n\tConnect uint64\n\t// Duration (in jiffies, a kernel internal unit of time) the NFS mount has\n\t// spent waiting for connections to the server to be established.\n\tConnectIdleTime uint64\n\t// Duration since the NFS mount last saw any RPC traffic.\n\tIdleTimeSeconds uint64\n\t// Number of RPC requests for this mount sent to the NFS server.\n\tSends uint64\n\t// Number of RPC responses for this mount received from the NFS server.\n\tReceives uint64\n\t// Number of times the NFS server sent a response with a transaction ID\n\t// unknown to this client.\n\tBadTransactionIDs uint64\n\t// A running counter, incremented on each request as the current difference\n\t// ebetween sends and receives.\n\tCumulativeActiveRequests uint64\n\t// A running counter, incremented on each request by the current backlog\n\t// queue size.\n\tCumulativeBacklog uint64\n\n\t// Stats below only available with stat version 1.1.\n\n\t// Maximum number of simultaneously active RPC requests ever used.\n\tMaximumRPCSlotsUsed uint64\n\t// A running counter, incremented on each request as the current size of the\n\t// sending queue.\n\tCumulativeSendingQueue uint64\n\t// A running counter, incremented on each request as the current size of the\n\t// pending queue.\n\tCumulativePendingQueue uint64\n}\n\n// parseMountStats parses a /proc/[pid]/mountstats file and returns a slice\n// of Mount structures containing detailed information about each mount.\n// If available, statistics for each mount are parsed as well.\nfunc parseMountStats(r io.Reader) ([]*Mount, error) {\n\tconst (\n\t\tdevice = \"device\"\n\t\tstatVersionPrefix = \"statvers=\"\n\n\t\tnfs3Type = \"nfs\"\n\t\tnfs4Type = \"nfs4\"\n\t)\n\n\tvar mounts []*Mount\n\n\ts := bufio.NewScanner(r)\n\tfor s.Scan() {\n\t\t// Only look for device entries in this function\n\t\tss := strings.Fields(string(s.Bytes()))\n\t\tif len(ss) == 0 || ss[0] != device {\n\t\t\tcontinue\n\t\t}\n\n\t\tm, err := parseMount(ss)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\t// Does this mount also possess statistics information?\n\t\tif len(ss) > deviceEntryLen {\n\t\t\t// Only NFSv3 and v4 are supported for parsing statistics\n\t\t\tif m.Type != nfs3Type && m.Type != nfs4Type {\n\t\t\t\treturn nil, fmt.Errorf(\"cannot parse MountStats for fstype %q\", m.Type)\n\t\t\t}\n\n\t\t\tstatVersion := strings.TrimPrefix(ss[8], statVersionPrefix)\n\n\t\t\tstats, err := parseMountStatsNFS(s, statVersion)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tm.Stats = stats\n\t\t}\n\n\t\tmounts = append(mounts, m)\n\t}\n\n\treturn mounts, s.Err()\n}\n\n// parseMount parses an entry in /proc/[pid]/mountstats in the format:\n// device [device] mounted on [mount] with fstype [type]\nfunc parseMount(ss []string) (*Mount, error) {\n\tif len(ss) < deviceEntryLen {\n\t\treturn nil, fmt.Errorf(\"invalid device entry: %v\", ss)\n\t}\n\n\t// Check for specific words appearing at specific indices to ensure\n\t// the format is consistent with what we expect\n\tformat := []struct {\n\t\ti int\n\t\ts string\n\t}{\n\t\t{i: 0, s: \"device\"},\n\t\t{i: 2, s: \"mounted\"},\n\t\t{i: 3, s: \"on\"},\n\t\t{i: 5, s: \"with\"},\n\t\t{i: 6, s: \"fstype\"},\n\t}\n\n\tfor _, f := range format {\n\t\tif ss[f.i] != f.s {\n\t\t\treturn nil, fmt.Errorf(\"invalid device entry: %v\", ss)\n\t\t}\n\t}\n\n\treturn &Mount{\n\t\tDevice: ss[1],\n\t\tMount: ss[4],\n\t\tType: ss[7],\n\t}, nil\n}\n\n// parseMountStatsNFS parses a MountStatsNFS by scanning additional information\n// related to NFS statistics.\nfunc parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, error) {\n\t// Field indicators for parsing specific types of data\n\tconst (\n\t\tfieldOpts = \"opts:\"\n\t\tfieldAge = \"age:\"\n\t\tfieldBytes = \"bytes:\"\n\t\tfieldEvents = \"events:\"\n\t\tfieldPerOpStats = \"per-op\"\n\t\tfieldTransport = \"xprt:\"\n\t)\n\n\tstats := &MountStatsNFS{\n\t\tStatVersion: statVersion,\n\t}\n\n\tfor s.Scan() {\n\t\tss := strings.Fields(string(s.Bytes()))\n\t\tif len(ss) == 0 {\n\t\t\tbreak\n\t\t}\n\n\t\tswitch ss[0] {\n\t\tcase fieldOpts:\n\t\t\tif len(ss) < 2 {\n\t\t\t\treturn nil, fmt.Errorf(\"not enough information for NFS stats: %v\", ss)\n\t\t\t}\n\t\t\tif stats.Opts == nil {\n\t\t\t\tstats.Opts = map[string]string{}\n\t\t\t}\n\t\t\tfor _, opt := range strings.Split(ss[1], \",\") {\n\t\t\t\tsplit := strings.Split(opt, \"=\")\n\t\t\t\tif len(split) == 2 {\n\t\t\t\t\tstats.Opts[split[0]] = split[1]\n\t\t\t\t} else {\n\t\t\t\t\tstats.Opts[opt] = \"\"\n\t\t\t\t}\n\t\t\t}\n\t\tcase fieldAge:\n\t\t\tif len(ss) < 2 {\n\t\t\t\treturn nil, fmt.Errorf(\"not enough information for NFS stats: %v\", ss)\n\t\t\t}\n\t\t\t// Age integer is in seconds\n\t\t\td, err := time.ParseDuration(ss[1] + \"s\")\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tstats.Age = d\n\t\tcase fieldBytes:\n\t\t\tif len(ss) < 2 {\n\t\t\t\treturn nil, fmt.Errorf(\"not enough information for NFS stats: %v\", ss)\n\t\t\t}\n\t\t\tbstats, err := parseNFSBytesStats(ss[1:])\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tstats.Bytes = *bstats\n\t\tcase fieldEvents:\n\t\t\tif len(ss) < 2 {\n\t\t\t\treturn nil, fmt.Errorf(\"not enough information for NFS stats: %v\", ss)\n\t\t\t}\n\t\t\testats, err := parseNFSEventsStats(ss[1:])\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tstats.Events = *estats\n\t\tcase fieldTransport:\n\t\t\tif len(ss) < 3 {\n\t\t\t\treturn nil, fmt.Errorf(\"not enough information for NFS transport stats: %v\", ss)\n\t\t\t}\n\n\t\t\ttstats, err := parseNFSTransportStats(ss[1:], statVersion)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tstats.Transport = *tstats\n\t\t}\n\n\t\t// When encountering \"per-operation statistics\", we must break this\n\t\t// loop and parse them separately to ensure we can terminate parsing\n\t\t// before reaching another device entry; hence why this 'if' statement\n\t\t// is not just another switch case\n\t\tif ss[0] == fieldPerOpStats {\n\t\t\tbreak\n\t\t}\n\t}\n\n\tif err := s.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\n\t// NFS per-operation stats appear last before the next device entry\n\tperOpStats, err := parseNFSOperationStats(s)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tstats.Operations = perOpStats\n\n\treturn stats, nil\n}\n\n// parseNFSBytesStats parses a NFSBytesStats line using an input set of\n// integer fields.\nfunc parseNFSBytesStats(ss []string) (*NFSBytesStats, error) {\n\tif len(ss) != fieldBytesLen {\n\t\treturn nil, fmt.Errorf(\"invalid NFS bytes stats: %v\", ss)\n\t}\n\n\tns := make([]uint64, 0, fieldBytesLen)\n\tfor _, s := range ss {\n\t\tn, err := strconv.ParseUint(s, 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tns = append(ns, n)\n\t}\n\n\treturn &NFSBytesStats{\n\t\tRead: ns[0],\n\t\tWrite: ns[1],\n\t\tDirectRead: ns[2],\n\t\tDirectWrite: ns[3],\n\t\tReadTotal: ns[4],\n\t\tWriteTotal: ns[5],\n\t\tReadPages: ns[6],\n\t\tWritePages: ns[7],\n\t}, nil\n}\n\n// parseNFSEventsStats parses a NFSEventsStats line using an input set of\n// integer fields.\nfunc parseNFSEventsStats(ss []string) (*NFSEventsStats, error) {\n\tif len(ss) != fieldEventsLen {\n\t\treturn nil, fmt.Errorf(\"invalid NFS events stats: %v\", ss)\n\t}\n\n\tns := make([]uint64, 0, fieldEventsLen)\n\tfor _, s := range ss {\n\t\tn, err := strconv.ParseUint(s, 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tns = append(ns, n)\n\t}\n\n\treturn &NFSEventsStats{\n\t\tInodeRevalidate: ns[0],\n\t\tDnodeRevalidate: ns[1],\n\t\tDataInvalidate: ns[2],\n\t\tAttributeInvalidate: ns[3],\n\t\tVFSOpen: ns[4],\n\t\tVFSLookup: ns[5],\n\t\tVFSAccess: ns[6],\n\t\tVFSUpdatePage: ns[7],\n\t\tVFSReadPage: ns[8],\n\t\tVFSReadPages: ns[9],\n\t\tVFSWritePage: ns[10],\n\t\tVFSWritePages: ns[11],\n\t\tVFSGetdents: ns[12],\n\t\tVFSSetattr: ns[13],\n\t\tVFSFlush: ns[14],\n\t\tVFSFsync: ns[15],\n\t\tVFSLock: ns[16],\n\t\tVFSFileRelease: ns[17],\n\t\tCongestionWait: ns[18],\n\t\tTruncation: ns[19],\n\t\tWriteExtension: ns[20],\n\t\tSillyRename: ns[21],\n\t\tShortRead: ns[22],\n\t\tShortWrite: ns[23],\n\t\tJukeboxDelay: ns[24],\n\t\tPNFSRead: ns[25],\n\t\tPNFSWrite: ns[26],\n\t}, nil\n}\n\n// parseNFSOperationStats parses a slice of NFSOperationStats by scanning\n// additional information about per-operation statistics until an empty\n// line is reached.\nfunc parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {\n\tconst (\n\t\t// Minimum number of expected fields in each per-operation statistics set\n\t\tminFields = 9\n\t)\n\n\tvar ops []NFSOperationStats\n\n\tfor s.Scan() {\n\t\tss := strings.Fields(string(s.Bytes()))\n\t\tif len(ss) == 0 {\n\t\t\t// Must break when reading a blank line after per-operation stats to\n\t\t\t// enable top-level function to parse the next device entry\n\t\t\tbreak\n\t\t}\n\n\t\tif len(ss) < minFields {\n\t\t\treturn nil, fmt.Errorf(\"invalid NFS per-operations stats: %v\", ss)\n\t\t}\n\n\t\t// Skip string operation name for integers\n\t\tns := make([]uint64, 0, minFields-1)\n\t\tfor _, st := range ss[1:] {\n\t\t\tn, err := strconv.ParseUint(st, 10, 64)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tns = append(ns, n)\n\t\t}\n\n\t\topStats := NFSOperationStats{\n\t\t\tOperation: strings.TrimSuffix(ss[0], \":\"),\n\t\t\tRequests: ns[0],\n\t\t\tTransmissions: ns[1],\n\t\t\tMajorTimeouts: ns[2],\n\t\t\tBytesSent: ns[3],\n\t\t\tBytesReceived: ns[4],\n\t\t\tCumulativeQueueMilliseconds: ns[5],\n\t\t\tCumulativeTotalResponseMilliseconds: ns[6],\n\t\t\tCumulativeTotalRequestMilliseconds: ns[7],\n\t\t}\n\n\t\tif len(ns) > 8 {\n\t\t\topStats.Errors = ns[8]\n\t\t}\n\n\t\tops = append(ops, opStats)\n\t}\n\n\treturn ops, s.Err()\n}\n\n// parseNFSTransportStats parses a NFSTransportStats line using an input set of\n// integer fields matched to a specific stats version.\nfunc parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats, error) {\n\t// Extract the protocol field. It is the only string value in the line\n\tprotocol := ss[0]\n\tss = ss[1:]\n\n\tswitch statVersion {\n\tcase statVersion10:\n\t\tvar expectedLength int\n\t\tif protocol == \"tcp\" {\n\t\t\texpectedLength = fieldTransport10TCPLen\n\t\t} else if protocol == \"udp\" {\n\t\t\texpectedLength = fieldTransport10UDPLen\n\t\t} else {\n\t\t\treturn nil, fmt.Errorf(\"invalid NFS protocol \\\"%s\\\" in stats 1.0 statement: %v\", protocol, ss)\n\t\t}\n\t\tif len(ss) != expectedLength {\n\t\t\treturn nil, fmt.Errorf(\"invalid NFS transport stats 1.0 statement: %v\", ss)\n\t\t}\n\tcase statVersion11:\n\t\tvar expectedLength int\n\t\tif protocol == \"tcp\" {\n\t\t\texpectedLength = fieldTransport11TCPLen\n\t\t} else if protocol == \"udp\" {\n\t\t\texpectedLength = fieldTransport11UDPLen\n\t\t} else {\n\t\t\treturn nil, fmt.Errorf(\"invalid NFS protocol \\\"%s\\\" in stats 1.1 statement: %v\", protocol, ss)\n\t\t}\n\t\tif len(ss) != expectedLength {\n\t\t\treturn nil, fmt.Errorf(\"invalid NFS transport stats 1.1 statement: %v\", ss)\n\t\t}\n\tdefault:\n\t\treturn nil, fmt.Errorf(\"unrecognized NFS transport stats version: %q\", statVersion)\n\t}\n\n\t// Allocate enough for v1.1 stats since zero value for v1.1 stats will be okay\n\t// in a v1.0 response. Since the stat length is bigger for TCP stats, we use\n\t// the TCP length here.\n\t//\n\t// Note: slice length must be set to length of v1.1 stats to avoid a panic when\n\t// only v1.0 stats are present.\n\t// See: https://github.com/prometheus/node_exporter/issues/571.\n\tns := make([]uint64, fieldTransport11TCPLen)\n\tfor i, s := range ss {\n\t\tn, err := strconv.ParseUint(s, 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tns[i] = n\n\t}\n\n\t// The fields differ depending on the transport protocol (TCP or UDP)\n\t// From https://utcc.utoronto.ca/%7Ecks/space/blog/linux/NFSMountstatsXprt\n\t//\n\t// For the udp RPC transport there is no connection count, connect idle time,\n\t// or idle time (fields #3, #4, and #5); all other fields are the same. So\n\t// we set them to 0 here.\n\tif protocol == \"udp\" {\n\t\tns = append(ns[:2], append(make([]uint64, 3), ns[2:]...)...)\n\t}\n\n\treturn &NFSTransportStats{\n\t\tProtocol: protocol,\n\t\tPort: ns[0],\n\t\tBind: ns[1],\n\t\tConnect: ns[2],\n\t\tConnectIdleTime: ns[3],\n\t\tIdleTimeSeconds: ns[4],\n\t\tSends: ns[5],\n\t\tReceives: ns[6],\n\t\tBadTransactionIDs: ns[7],\n\t\tCumulativeActiveRequests: ns[8],\n\t\tCumulativeBacklog: ns[9],\n\t\tMaximumRPCSlotsUsed: ns[10],\n\t\tCumulativeSendingQueue: ns[11],\n\t\tCumulativePendingQueue: ns[12],\n\t}, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_conntrackstat.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// A ConntrackStatEntry represents one line from net/stat/nf_conntrack\n// and contains netfilter conntrack statistics at one CPU core.\ntype ConntrackStatEntry struct {\n\tEntries uint64\n\tFound uint64\n\tInvalid uint64\n\tIgnore uint64\n\tInsert uint64\n\tInsertFailed uint64\n\tDrop uint64\n\tEarlyDrop uint64\n\tSearchRestart uint64\n}\n\n// ConntrackStat retrieves netfilter's conntrack statistics, split by CPU cores.\nfunc (fs FS) ConntrackStat() ([]ConntrackStatEntry, error) {\n\treturn readConntrackStat(fs.proc.Path(\"net\", \"stat\", \"nf_conntrack\"))\n}\n\n// Parses a slice of ConntrackStatEntries from the given filepath.\nfunc readConntrackStat(path string) ([]ConntrackStatEntry, error) {\n\t// This file is small and can be read with one syscall.\n\tb, err := util.ReadFileNoStat(path)\n\tif err != nil {\n\t\t// Do not wrap this error so the caller can detect os.IsNotExist and\n\t\t// similar conditions.\n\t\treturn nil, err\n\t}\n\n\tstat, err := parseConntrackStat(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to read conntrack stats from %q: %w\", path, err)\n\t}\n\n\treturn stat, nil\n}\n\n// Reads the contents of a conntrack statistics file and parses a slice of ConntrackStatEntries.\nfunc parseConntrackStat(r io.Reader) ([]ConntrackStatEntry, error) {\n\tvar entries []ConntrackStatEntry\n\n\tscanner := bufio.NewScanner(r)\n\tscanner.Scan()\n\tfor scanner.Scan() {\n\t\tfields := strings.Fields(scanner.Text())\n\t\tconntrackEntry, err := parseConntrackStatEntry(fields)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tentries = append(entries, *conntrackEntry)\n\t}\n\n\treturn entries, nil\n}\n\n// Parses a ConntrackStatEntry from given array of fields.\nfunc parseConntrackStatEntry(fields []string) (*ConntrackStatEntry, error) {\n\tif len(fields) != 17 {\n\t\treturn nil, fmt.Errorf(\"invalid conntrackstat entry, missing fields\")\n\t}\n\tentry := &ConntrackStatEntry{}\n\n\tentries, err := parseConntrackStatField(fields[0])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Entries = entries\n\n\tfound, err := parseConntrackStatField(fields[2])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Found = found\n\n\tinvalid, err := parseConntrackStatField(fields[4])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Invalid = invalid\n\n\tignore, err := parseConntrackStatField(fields[5])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Ignore = ignore\n\n\tinsert, err := parseConntrackStatField(fields[8])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Insert = insert\n\n\tinsertFailed, err := parseConntrackStatField(fields[9])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.InsertFailed = insertFailed\n\n\tdrop, err := parseConntrackStatField(fields[10])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.Drop = drop\n\n\tearlyDrop, err := parseConntrackStatField(fields[11])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.EarlyDrop = earlyDrop\n\n\tsearchRestart, err := parseConntrackStatField(fields[16])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tentry.SearchRestart = searchRestart\n\n\treturn entry, nil\n}\n\n// Parses a uint64 from given hex in string.\nfunc parseConntrackStatField(field string) (uint64, error) {\n\tval, err := strconv.ParseUint(field, 16, 64)\n\tif err != nil {\n\t\treturn 0, fmt.Errorf(\"couldn't parse %q field: %w\", field, err)\n\t}\n\treturn val, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_dev.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"errors\"\n\t\"os\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// NetDevLine is single line parsed from /proc/net/dev or /proc/[pid]/net/dev.\ntype NetDevLine struct {\n\tName string `json:\"name\"` // The name of the interface.\n\tRxBytes uint64 `json:\"rx_bytes\"` // Cumulative count of bytes received.\n\tRxPackets uint64 `json:\"rx_packets\"` // Cumulative count of packets received.\n\tRxErrors uint64 `json:\"rx_errors\"` // Cumulative count of receive errors encountered.\n\tRxDropped uint64 `json:\"rx_dropped\"` // Cumulative count of packets dropped while receiving.\n\tRxFIFO uint64 `json:\"rx_fifo\"` // Cumulative count of FIFO buffer errors.\n\tRxFrame uint64 `json:\"rx_frame\"` // Cumulative count of packet framing errors.\n\tRxCompressed uint64 `json:\"rx_compressed\"` // Cumulative count of compressed packets received by the device driver.\n\tRxMulticast uint64 `json:\"rx_multicast\"` // Cumulative count of multicast frames received by the device driver.\n\tTxBytes uint64 `json:\"tx_bytes\"` // Cumulative count of bytes transmitted.\n\tTxPackets uint64 `json:\"tx_packets\"` // Cumulative count of packets transmitted.\n\tTxErrors uint64 `json:\"tx_errors\"` // Cumulative count of transmit errors encountered.\n\tTxDropped uint64 `json:\"tx_dropped\"` // Cumulative count of packets dropped while transmitting.\n\tTxFIFO uint64 `json:\"tx_fifo\"` // Cumulative count of FIFO buffer errors.\n\tTxCollisions uint64 `json:\"tx_collisions\"` // Cumulative count of collisions detected on the interface.\n\tTxCarrier uint64 `json:\"tx_carrier\"` // Cumulative count of carrier losses detected by the device driver.\n\tTxCompressed uint64 `json:\"tx_compressed\"` // Cumulative count of compressed packets transmitted by the device driver.\n}\n\n// NetDev is parsed from /proc/net/dev or /proc/[pid]/net/dev. The map keys\n// are interface names.\ntype NetDev map[string]NetDevLine\n\n// NetDev returns kernel/system statistics read from /proc/net/dev.\nfunc (fs FS) NetDev() (NetDev, error) {\n\treturn newNetDev(fs.proc.Path(\"net/dev\"))\n}\n\n// NetDev returns kernel/system statistics read from /proc/[pid]/net/dev.\nfunc (p Proc) NetDev() (NetDev, error) {\n\treturn newNetDev(p.path(\"net/dev\"))\n}\n\n// newNetDev creates a new NetDev from the contents of the given file.\nfunc newNetDev(file string) (NetDev, error) {\n\tf, err := os.Open(file)\n\tif err != nil {\n\t\treturn NetDev{}, err\n\t}\n\tdefer f.Close()\n\n\tnetDev := NetDev{}\n\ts := bufio.NewScanner(f)\n\tfor n := 0; s.Scan(); n++ {\n\t\t// Skip the 2 header lines.\n\t\tif n < 2 {\n\t\t\tcontinue\n\t\t}\n\n\t\tline, err := netDev.parseLine(s.Text())\n\t\tif err != nil {\n\t\t\treturn netDev, err\n\t\t}\n\n\t\tnetDev[line.Name] = *line\n\t}\n\n\treturn netDev, s.Err()\n}\n\n// parseLine parses a single line from the /proc/net/dev file. Header lines\n// must be filtered prior to calling this method.\nfunc (netDev NetDev) parseLine(rawLine string) (*NetDevLine, error) {\n\tidx := strings.LastIndex(rawLine, \":\")\n\tif idx == -1 {\n\t\treturn nil, errors.New(\"invalid net/dev line, missing colon\")\n\t}\n\tfields := strings.Fields(strings.TrimSpace(rawLine[idx+1:]))\n\n\tvar err error\n\tline := &NetDevLine{}\n\n\t// Interface Name\n\tline.Name = strings.TrimSpace(rawLine[:idx])\n\tif line.Name == \"\" {\n\t\treturn nil, errors.New(\"invalid net/dev line, empty interface name\")\n\t}\n\n\t// RX\n\tline.RxBytes, err = strconv.ParseUint(fields[0], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxPackets, err = strconv.ParseUint(fields[1], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxErrors, err = strconv.ParseUint(fields[2], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxDropped, err = strconv.ParseUint(fields[3], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxFIFO, err = strconv.ParseUint(fields[4], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxFrame, err = strconv.ParseUint(fields[5], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxCompressed, err = strconv.ParseUint(fields[6], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.RxMulticast, err = strconv.ParseUint(fields[7], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// TX\n\tline.TxBytes, err = strconv.ParseUint(fields[8], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxPackets, err = strconv.ParseUint(fields[9], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxErrors, err = strconv.ParseUint(fields[10], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxDropped, err = strconv.ParseUint(fields[11], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxFIFO, err = strconv.ParseUint(fields[12], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxCollisions, err = strconv.ParseUint(fields[13], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxCarrier, err = strconv.ParseUint(fields[14], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.TxCompressed, err = strconv.ParseUint(fields[15], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn line, nil\n}\n\n// Total aggregates the values across interfaces and returns a new NetDevLine.\n// The Name field will be a sorted comma separated list of interface names.\nfunc (netDev NetDev) Total() NetDevLine {\n\ttotal := NetDevLine{}\n\n\tnames := make([]string, 0, len(netDev))\n\tfor _, ifc := range netDev {\n\t\tnames = append(names, ifc.Name)\n\t\ttotal.RxBytes += ifc.RxBytes\n\t\ttotal.RxPackets += ifc.RxPackets\n\t\ttotal.RxErrors += ifc.RxErrors\n\t\ttotal.RxDropped += ifc.RxDropped\n\t\ttotal.RxFIFO += ifc.RxFIFO\n\t\ttotal.RxFrame += ifc.RxFrame\n\t\ttotal.RxCompressed += ifc.RxCompressed\n\t\ttotal.RxMulticast += ifc.RxMulticast\n\t\ttotal.TxBytes += ifc.TxBytes\n\t\ttotal.TxPackets += ifc.TxPackets\n\t\ttotal.TxErrors += ifc.TxErrors\n\t\ttotal.TxDropped += ifc.TxDropped\n\t\ttotal.TxFIFO += ifc.TxFIFO\n\t\ttotal.TxCollisions += ifc.TxCollisions\n\t\ttotal.TxCarrier += ifc.TxCarrier\n\t\ttotal.TxCompressed += ifc.TxCompressed\n\t}\n\tsort.Strings(names)\n\ttotal.Name = strings.Join(names, \", \")\n\n\treturn total\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_ip_socket.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"encoding/hex\"\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\nconst (\n\t// readLimit is used by io.LimitReader while reading the content of the\n\t// /proc/net/udp{,6} files. The number of lines inside such a file is dynamic\n\t// as each line represents a single used socket.\n\t// In theory, the number of available sockets is 65535 (2^16 - 1) per IP.\n\t// With e.g. 150 Byte per line and the maximum number of 65535,\n\t// the reader needs to handle 150 Byte * 65535 =~ 10 MB for a single IP.\n\treadLimit = 4294967296 // Byte -> 4 GiB\n)\n\n// This contains generic data structures for both udp and tcp sockets.\ntype (\n\t// NetIPSocket represents the contents of /proc/net/{t,u}dp{,6} file without the header.\n\tNetIPSocket []*netIPSocketLine\n\n\t// NetIPSocketSummary provides already computed values like the total queue lengths or\n\t// the total number of used sockets. In contrast to NetIPSocket it does not collect\n\t// the parsed lines into a slice.\n\tNetIPSocketSummary struct {\n\t\t// TxQueueLength shows the total queue length of all parsed tx_queue lengths.\n\t\tTxQueueLength uint64\n\t\t// RxQueueLength shows the total queue length of all parsed rx_queue lengths.\n\t\tRxQueueLength uint64\n\t\t// UsedSockets shows the total number of parsed lines representing the\n\t\t// number of used sockets.\n\t\tUsedSockets uint64\n\t}\n\n\t// netIPSocketLine represents the fields parsed from a single line\n\t// in /proc/net/{t,u}dp{,6}. Fields which are not used by IPSocket are skipped.\n\t// For the proc file format details, see https://linux.die.net/man/5/proc.\n\tnetIPSocketLine struct {\n\t\tSl uint64\n\t\tLocalAddr net.IP\n\t\tLocalPort uint64\n\t\tRemAddr net.IP\n\t\tRemPort uint64\n\t\tSt uint64\n\t\tTxQueue uint64\n\t\tRxQueue uint64\n\t\tUID uint64\n\t\tInode uint64\n\t}\n)\n\nfunc newNetIPSocket(file string) (NetIPSocket, error) {\n\tf, err := os.Open(file)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer f.Close()\n\n\tvar netIPSocket NetIPSocket\n\n\tlr := io.LimitReader(f, readLimit)\n\ts := bufio.NewScanner(lr)\n\ts.Scan() // skip first line with headers\n\tfor s.Scan() {\n\t\tfields := strings.Fields(s.Text())\n\t\tline, err := parseNetIPSocketLine(fields)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tnetIPSocket = append(netIPSocket, line)\n\t}\n\tif err := s.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\treturn netIPSocket, nil\n}\n\n// newNetIPSocketSummary creates a new NetIPSocket{,6} from the contents of the given file.\nfunc newNetIPSocketSummary(file string) (*NetIPSocketSummary, error) {\n\tf, err := os.Open(file)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer f.Close()\n\n\tvar netIPSocketSummary NetIPSocketSummary\n\n\tlr := io.LimitReader(f, readLimit)\n\ts := bufio.NewScanner(lr)\n\ts.Scan() // skip first line with headers\n\tfor s.Scan() {\n\t\tfields := strings.Fields(s.Text())\n\t\tline, err := parseNetIPSocketLine(fields)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tnetIPSocketSummary.TxQueueLength += line.TxQueue\n\t\tnetIPSocketSummary.RxQueueLength += line.RxQueue\n\t\tnetIPSocketSummary.UsedSockets++\n\t}\n\tif err := s.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\treturn &netIPSocketSummary, nil\n}\n\n// the /proc/net/{t,u}dp{,6} files are network byte order for ipv4 and for ipv6 the address is four words consisting of four bytes each. In each of those four words the four bytes are written in reverse order.\n\nfunc parseIP(hexIP string) (net.IP, error) {\n\tvar byteIP []byte\n\tbyteIP, err := hex.DecodeString(hexIP)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse address field in socket line %q\", hexIP)\n\t}\n\tswitch len(byteIP) {\n\tcase 4:\n\t\treturn net.IP{byteIP[3], byteIP[2], byteIP[1], byteIP[0]}, nil\n\tcase 16:\n\t\ti := net.IP{\n\t\t\tbyteIP[3], byteIP[2], byteIP[1], byteIP[0],\n\t\t\tbyteIP[7], byteIP[6], byteIP[5], byteIP[4],\n\t\t\tbyteIP[11], byteIP[10], byteIP[9], byteIP[8],\n\t\t\tbyteIP[15], byteIP[14], byteIP[13], byteIP[12],\n\t\t}\n\t\treturn i, nil\n\tdefault:\n\t\treturn nil, fmt.Errorf(\"Unable to parse IP %s\", hexIP)\n\t}\n}\n\n// parseNetIPSocketLine parses a single line, represented by a list of fields.\nfunc parseNetIPSocketLine(fields []string) (*netIPSocketLine, error) {\n\tline := &netIPSocketLine{}\n\tif len(fields) < 10 {\n\t\treturn nil, fmt.Errorf(\n\t\t\t\"cannot parse net socket line as it has less then 10 columns %q\",\n\t\t\tstrings.Join(fields, \" \"),\n\t\t)\n\t}\n\tvar err error // parse error\n\n\t// sl\n\ts := strings.Split(fields[0], \":\")\n\tif len(s) != 2 {\n\t\treturn nil, fmt.Errorf(\"cannot parse sl field in socket line %q\", fields[0])\n\t}\n\n\tif line.Sl, err = strconv.ParseUint(s[0], 0, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse sl value in socket line: %w\", err)\n\t}\n\t// local_address\n\tl := strings.Split(fields[1], \":\")\n\tif len(l) != 2 {\n\t\treturn nil, fmt.Errorf(\"cannot parse local_address field in socket line %q\", fields[1])\n\t}\n\tif line.LocalAddr, err = parseIP(l[0]); err != nil {\n\t\treturn nil, err\n\t}\n\tif line.LocalPort, err = strconv.ParseUint(l[1], 16, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse local_address port value in socket line: %w\", err)\n\t}\n\n\t// remote_address\n\tr := strings.Split(fields[2], \":\")\n\tif len(r) != 2 {\n\t\treturn nil, fmt.Errorf(\"cannot parse rem_address field in socket line %q\", fields[1])\n\t}\n\tif line.RemAddr, err = parseIP(r[0]); err != nil {\n\t\treturn nil, err\n\t}\n\tif line.RemPort, err = strconv.ParseUint(r[1], 16, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse rem_address port value in socket line: %w\", err)\n\t}\n\n\t// st\n\tif line.St, err = strconv.ParseUint(fields[3], 16, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse st value in socket line: %w\", err)\n\t}\n\n\t// tx_queue and rx_queue\n\tq := strings.Split(fields[4], \":\")\n\tif len(q) != 2 {\n\t\treturn nil, fmt.Errorf(\n\t\t\t\"cannot parse tx/rx queues in socket line as it has a missing colon %q\",\n\t\t\tfields[4],\n\t\t)\n\t}\n\tif line.TxQueue, err = strconv.ParseUint(q[0], 16, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse tx_queue value in socket line: %w\", err)\n\t}\n\tif line.RxQueue, err = strconv.ParseUint(q[1], 16, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse rx_queue value in socket line: %w\", err)\n\t}\n\n\t// uid\n\tif line.UID, err = strconv.ParseUint(fields[7], 0, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse uid value in socket line: %w\", err)\n\t}\n\n\t// inode\n\tif line.Inode, err = strconv.ParseUint(fields[9], 0, 64); err != nil {\n\t\treturn nil, fmt.Errorf(\"cannot parse inode value in socket line: %w\", err)\n\t}\n\n\treturn line, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_protocols.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// NetProtocolStats stores the contents from /proc/net/protocols.\ntype NetProtocolStats map[string]NetProtocolStatLine\n\n// NetProtocolStatLine contains a single line parsed from /proc/net/protocols. We\n// only care about the first six columns as the rest are not likely to change\n// and only serve to provide a set of capabilities for each protocol.\ntype NetProtocolStatLine struct {\n\tName string // 0 The name of the protocol\n\tSize uint64 // 1 The size, in bytes, of a given protocol structure. e.g. sizeof(struct tcp_sock) or sizeof(struct unix_sock)\n\tSockets int64 // 2 Number of sockets in use by this protocol\n\tMemory int64 // 3 Number of 4KB pages allocated by all sockets of this protocol\n\tPressure int // 4 This is either yes, no, or NI (not implemented). For the sake of simplicity we treat NI as not experiencing memory pressure.\n\tMaxHeader uint64 // 5 Protocol specific max header size\n\tSlab bool // 6 Indicates whether or not memory is allocated from the SLAB\n\tModuleName string // 7 The name of the module that implemented this protocol or \"kernel\" if not from a module\n\tCapabilities NetProtocolCapabilities\n}\n\n// NetProtocolCapabilities contains a list of capabilities for each protocol.\ntype NetProtocolCapabilities struct {\n\tClose bool // 8\n\tConnect bool // 9\n\tDisconnect bool // 10\n\tAccept bool // 11\n\tIoCtl bool // 12\n\tInit bool // 13\n\tDestroy bool // 14\n\tShutdown bool // 15\n\tSetSockOpt bool // 16\n\tGetSockOpt bool // 17\n\tSendMsg bool // 18\n\tRecvMsg bool // 19\n\tSendPage bool // 20\n\tBind bool // 21\n\tBacklogRcv bool // 22\n\tHash bool // 23\n\tUnHash bool // 24\n\tGetPort bool // 25\n\tEnterMemoryPressure bool // 26\n}\n\n// NetProtocols reads stats from /proc/net/protocols and returns a map of\n// PortocolStatLine entries. As of this writing no official Linux Documentation\n// exists, however the source is fairly self-explanatory and the format seems\n// stable since its introduction in 2.6.12-rc2\n// Linux 2.6.12-rc2 - https://elixir.bootlin.com/linux/v2.6.12-rc2/source/net/core/sock.c#L1452\n// Linux 5.10 - https://elixir.bootlin.com/linux/v5.10.4/source/net/core/sock.c#L3586\nfunc (fs FS) NetProtocols() (NetProtocolStats, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"net/protocols\"))\n\tif err != nil {\n\t\treturn NetProtocolStats{}, err\n\t}\n\treturn parseNetProtocols(bufio.NewScanner(bytes.NewReader(data)))\n}\n\nfunc parseNetProtocols(s *bufio.Scanner) (NetProtocolStats, error) {\n\tnps := NetProtocolStats{}\n\n\t// Skip the header line\n\ts.Scan()\n\n\tfor s.Scan() {\n\t\tline, err := nps.parseLine(s.Text())\n\t\tif err != nil {\n\t\t\treturn NetProtocolStats{}, err\n\t\t}\n\n\t\tnps[line.Name] = *line\n\t}\n\treturn nps, nil\n}\n\nfunc (ps NetProtocolStats) parseLine(rawLine string) (*NetProtocolStatLine, error) {\n\tline := &NetProtocolStatLine{Capabilities: NetProtocolCapabilities{}}\n\tvar err error\n\tconst enabled = \"yes\"\n\tconst disabled = \"no\"\n\n\tfields := strings.Fields(rawLine)\n\tline.Name = fields[0]\n\tline.Size, err = strconv.ParseUint(fields[1], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.Sockets, err = strconv.ParseInt(fields[2], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tline.Memory, err = strconv.ParseInt(fields[3], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tif fields[4] == enabled {\n\t\tline.Pressure = 1\n\t} else if fields[4] == disabled {\n\t\tline.Pressure = 0\n\t} else {\n\t\tline.Pressure = -1\n\t}\n\tline.MaxHeader, err = strconv.ParseUint(fields[5], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tif fields[6] == enabled {\n\t\tline.Slab = true\n\t} else if fields[6] == disabled {\n\t\tline.Slab = false\n\t} else {\n\t\treturn nil, fmt.Errorf(\"unable to parse capability for protocol: %s\", line.Name)\n\t}\n\tline.ModuleName = fields[7]\n\n\terr = line.Capabilities.parseCapabilities(fields[8:])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn line, nil\n}\n\nfunc (pc *NetProtocolCapabilities) parseCapabilities(capabilities []string) error {\n\t// The capabilities are all bools so we can loop over to map them\n\tcapabilityFields := [...]*bool{\n\t\t&pc.Close,\n\t\t&pc.Connect,\n\t\t&pc.Disconnect,\n\t\t&pc.Accept,\n\t\t&pc.IoCtl,\n\t\t&pc.Init,\n\t\t&pc.Destroy,\n\t\t&pc.Shutdown,\n\t\t&pc.SetSockOpt,\n\t\t&pc.GetSockOpt,\n\t\t&pc.SendMsg,\n\t\t&pc.RecvMsg,\n\t\t&pc.SendPage,\n\t\t&pc.Bind,\n\t\t&pc.BacklogRcv,\n\t\t&pc.Hash,\n\t\t&pc.UnHash,\n\t\t&pc.GetPort,\n\t\t&pc.EnterMemoryPressure,\n\t}\n\n\tfor i := 0; i < len(capabilities); i++ {\n\t\tif capabilities[i] == \"y\" {\n\t\t\t*capabilityFields[i] = true\n\t\t} else if capabilities[i] == \"n\" {\n\t\t\t*capabilityFields[i] = false\n\t\t} else {\n\t\t\treturn fmt.Errorf(\"unable to parse capability block for protocol: position %d\", i)\n\t\t}\n\t}\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_sockstat.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// A NetSockstat contains the output of /proc/net/sockstat{,6} for IPv4 or IPv6,\n// respectively.\ntype NetSockstat struct {\n\t// Used is non-nil for IPv4 sockstat results, but nil for IPv6.\n\tUsed *int\n\tProtocols []NetSockstatProtocol\n}\n\n// A NetSockstatProtocol contains statistics about a given socket protocol.\n// Pointer fields indicate that the value may or may not be present on any\n// given protocol.\ntype NetSockstatProtocol struct {\n\tProtocol string\n\tInUse int\n\tOrphan *int\n\tTW *int\n\tAlloc *int\n\tMem *int\n\tMemory *int\n}\n\n// NetSockstat retrieves IPv4 socket statistics.\nfunc (fs FS) NetSockstat() (*NetSockstat, error) {\n\treturn readSockstat(fs.proc.Path(\"net\", \"sockstat\"))\n}\n\n// NetSockstat6 retrieves IPv6 socket statistics.\n//\n// If IPv6 is disabled on this kernel, the returned error can be checked with\n// os.IsNotExist.\nfunc (fs FS) NetSockstat6() (*NetSockstat, error) {\n\treturn readSockstat(fs.proc.Path(\"net\", \"sockstat6\"))\n}\n\n// readSockstat opens and parses a NetSockstat from the input file.\nfunc readSockstat(name string) (*NetSockstat, error) {\n\t// This file is small and can be read with one syscall.\n\tb, err := util.ReadFileNoStat(name)\n\tif err != nil {\n\t\t// Do not wrap this error so the caller can detect os.IsNotExist and\n\t\t// similar conditions.\n\t\treturn nil, err\n\t}\n\n\tstat, err := parseSockstat(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to read sockstats from %q: %w\", name, err)\n\t}\n\n\treturn stat, nil\n}\n\n// parseSockstat reads the contents of a sockstat file and parses a NetSockstat.\nfunc parseSockstat(r io.Reader) (*NetSockstat, error) {\n\tvar stat NetSockstat\n\ts := bufio.NewScanner(r)\n\tfor s.Scan() {\n\t\t// Expect a minimum of a protocol and one key/value pair.\n\t\tfields := strings.Split(s.Text(), \" \")\n\t\tif len(fields) < 3 {\n\t\t\treturn nil, fmt.Errorf(\"malformed sockstat line: %q\", s.Text())\n\t\t}\n\n\t\t// The remaining fields are key/value pairs.\n\t\tkvs, err := parseSockstatKVs(fields[1:])\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"error parsing sockstat key/value pairs from %q: %w\", s.Text(), err)\n\t\t}\n\n\t\t// The first field is the protocol. We must trim its colon suffix.\n\t\tproto := strings.TrimSuffix(fields[0], \":\")\n\t\tswitch proto {\n\t\tcase \"sockets\":\n\t\t\t// Special case: IPv4 has a sockets \"used\" key/value pair that we\n\t\t\t// embed at the top level of the structure.\n\t\t\tused := kvs[\"used\"]\n\t\t\tstat.Used = &used\n\t\tdefault:\n\t\t\t// Parse all other lines as individual protocols.\n\t\t\tnsp := parseSockstatProtocol(kvs)\n\t\t\tnsp.Protocol = proto\n\t\t\tstat.Protocols = append(stat.Protocols, nsp)\n\t\t}\n\t}\n\n\tif err := s.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn &stat, nil\n}\n\n// parseSockstatKVs parses a string slice into a map of key/value pairs.\nfunc parseSockstatKVs(kvs []string) (map[string]int, error) {\n\tif len(kvs)%2 != 0 {\n\t\treturn nil, errors.New(\"odd number of fields in key/value pairs\")\n\t}\n\n\t// Iterate two values at a time to gather key/value pairs.\n\tout := make(map[string]int, len(kvs)/2)\n\tfor i := 0; i < len(kvs); i += 2 {\n\t\tvp := util.NewValueParser(kvs[i+1])\n\t\tout[kvs[i]] = vp.Int()\n\n\t\tif err := vp.Err(); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\treturn out, nil\n}\n\n// parseSockstatProtocol parses a NetSockstatProtocol from the input kvs map.\nfunc parseSockstatProtocol(kvs map[string]int) NetSockstatProtocol {\n\tvar nsp NetSockstatProtocol\n\tfor k, v := range kvs {\n\t\t// Capture the range variable to ensure we get unique pointers for\n\t\t// each of the optional fields.\n\t\tv := v\n\t\tswitch k {\n\t\tcase \"inuse\":\n\t\t\tnsp.InUse = v\n\t\tcase \"orphan\":\n\t\t\tnsp.Orphan = &v\n\t\tcase \"tw\":\n\t\t\tnsp.TW = &v\n\t\tcase \"alloc\":\n\t\t\tnsp.Alloc = &v\n\t\tcase \"mem\":\n\t\t\tnsp.Mem = &v\n\t\tcase \"memory\":\n\t\t\tnsp.Memory = &v\n\t\t}\n\t}\n\n\treturn nsp\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_softnet.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// For the proc file format details,\n// See:\n// * Linux 2.6.23 https://elixir.bootlin.com/linux/v2.6.23/source/net/core/dev.c#L2343\n// * Linux 4.17 https://elixir.bootlin.com/linux/v4.17/source/net/core/net-procfs.c#L162\n// and https://elixir.bootlin.com/linux/v4.17/source/include/linux/netdevice.h#L2810.\n\n// SoftnetStat contains a single row of data from /proc/net/softnet_stat.\ntype SoftnetStat struct {\n\t// Number of processed packets.\n\tProcessed uint32\n\t// Number of dropped packets.\n\tDropped uint32\n\t// Number of times processing packets ran out of quota.\n\tTimeSqueezed uint32\n}\n\nvar softNetProcFile = \"net/softnet_stat\"\n\n// NetSoftnetStat reads data from /proc/net/softnet_stat.\nfunc (fs FS) NetSoftnetStat() ([]SoftnetStat, error) {\n\tb, err := util.ReadFileNoStat(fs.proc.Path(softNetProcFile))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tentries, err := parseSoftnet(bytes.NewReader(b))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse /proc/net/softnet_stat: %w\", err)\n\t}\n\n\treturn entries, nil\n}\n\nfunc parseSoftnet(r io.Reader) ([]SoftnetStat, error) {\n\tconst minColumns = 9\n\n\ts := bufio.NewScanner(r)\n\n\tvar stats []SoftnetStat\n\tfor s.Scan() {\n\t\tcolumns := strings.Fields(s.Text())\n\t\twidth := len(columns)\n\n\t\tif width < minColumns {\n\t\t\treturn nil, fmt.Errorf(\"%d columns were detected, but at least %d were expected\", width, minColumns)\n\t\t}\n\n\t\t// We only parse the first three columns at the moment.\n\t\tus, err := parseHexUint32s(columns[0:3])\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tstats = append(stats, SoftnetStat{\n\t\t\tProcessed: us[0],\n\t\t\tDropped: us[1],\n\t\t\tTimeSqueezed: us[2],\n\t\t})\n\t}\n\n\treturn stats, nil\n}\n\nfunc parseHexUint32s(ss []string) ([]uint32, error) {\n\tus := make([]uint32, 0, len(ss))\n\tfor _, s := range ss {\n\t\tu, err := strconv.ParseUint(s, 16, 32)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tus = append(us, uint32(u))\n\t}\n\n\treturn us, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_tcp.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\ntype (\n\t// NetTCP represents the contents of /proc/net/tcp{,6} file without the header.\n\tNetTCP []*netIPSocketLine\n\n\t// NetTCPSummary provides already computed values like the total queue lengths or\n\t// the total number of used sockets. In contrast to NetTCP it does not collect\n\t// the parsed lines into a slice.\n\tNetTCPSummary NetIPSocketSummary\n)\n\n// NetTCP returns the IPv4 kernel/networking statistics for TCP datagrams\n// read from /proc/net/tcp.\nfunc (fs FS) NetTCP() (NetTCP, error) {\n\treturn newNetTCP(fs.proc.Path(\"net/tcp\"))\n}\n\n// NetTCP6 returns the IPv6 kernel/networking statistics for TCP datagrams\n// read from /proc/net/tcp6.\nfunc (fs FS) NetTCP6() (NetTCP, error) {\n\treturn newNetTCP(fs.proc.Path(\"net/tcp6\"))\n}\n\n// NetTCPSummary returns already computed statistics like the total queue lengths\n// for TCP datagrams read from /proc/net/tcp.\nfunc (fs FS) NetTCPSummary() (*NetTCPSummary, error) {\n\treturn newNetTCPSummary(fs.proc.Path(\"net/tcp\"))\n}\n\n// NetTCP6Summary returns already computed statistics like the total queue lengths\n// for TCP datagrams read from /proc/net/tcp6.\nfunc (fs FS) NetTCP6Summary() (*NetTCPSummary, error) {\n\treturn newNetTCPSummary(fs.proc.Path(\"net/tcp6\"))\n}\n\n// newNetTCP creates a new NetTCP{,6} from the contents of the given file.\nfunc newNetTCP(file string) (NetTCP, error) {\n\tn, err := newNetIPSocket(file)\n\tn1 := NetTCP(n)\n\treturn n1, err\n}\n\nfunc newNetTCPSummary(file string) (*NetTCPSummary, error) {\n\tn, err := newNetIPSocketSummary(file)\n\tif n == nil {\n\t\treturn nil, err\n\t}\n\tn1 := NetTCPSummary(*n)\n\treturn &n1, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_udp.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\ntype (\n\t// NetUDP represents the contents of /proc/net/udp{,6} file without the header.\n\tNetUDP []*netIPSocketLine\n\n\t// NetUDPSummary provides already computed values like the total queue lengths or\n\t// the total number of used sockets. In contrast to NetUDP it does not collect\n\t// the parsed lines into a slice.\n\tNetUDPSummary NetIPSocketSummary\n)\n\n// NetUDP returns the IPv4 kernel/networking statistics for UDP datagrams\n// read from /proc/net/udp.\nfunc (fs FS) NetUDP() (NetUDP, error) {\n\treturn newNetUDP(fs.proc.Path(\"net/udp\"))\n}\n\n// NetUDP6 returns the IPv6 kernel/networking statistics for UDP datagrams\n// read from /proc/net/udp6.\nfunc (fs FS) NetUDP6() (NetUDP, error) {\n\treturn newNetUDP(fs.proc.Path(\"net/udp6\"))\n}\n\n// NetUDPSummary returns already computed statistics like the total queue lengths\n// for UDP datagrams read from /proc/net/udp.\nfunc (fs FS) NetUDPSummary() (*NetUDPSummary, error) {\n\treturn newNetUDPSummary(fs.proc.Path(\"net/udp\"))\n}\n\n// NetUDP6Summary returns already computed statistics like the total queue lengths\n// for UDP datagrams read from /proc/net/udp6.\nfunc (fs FS) NetUDP6Summary() (*NetUDPSummary, error) {\n\treturn newNetUDPSummary(fs.proc.Path(\"net/udp6\"))\n}\n\n// newNetUDP creates a new NetUDP{,6} from the contents of the given file.\nfunc newNetUDP(file string) (NetUDP, error) {\n\tn, err := newNetIPSocket(file)\n\tn1 := NetUDP(n)\n\treturn n1, err\n}\n\nfunc newNetUDPSummary(file string) (*NetUDPSummary, error) {\n\tn, err := newNetIPSocketSummary(file)\n\tif n == nil {\n\t\treturn nil, err\n\t}\n\tn1 := NetUDPSummary(*n)\n\treturn &n1, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_unix.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// For the proc file format details,\n// see https://elixir.bootlin.com/linux/v4.17/source/net/unix/af_unix.c#L2815\n// and https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/net.h#L48.\n\n// Constants for the various /proc/net/unix enumerations.\n// TODO: match against x/sys/unix or similar?\nconst (\n\tnetUnixTypeStream = 1\n\tnetUnixTypeDgram = 2\n\tnetUnixTypeSeqpacket = 5\n\n\tnetUnixFlagDefault = 0\n\tnetUnixFlagListen = 1 << 16\n\n\tnetUnixStateUnconnected = 1\n\tnetUnixStateConnecting = 2\n\tnetUnixStateConnected = 3\n\tnetUnixStateDisconnected = 4\n)\n\n// NetUNIXType is the type of the type field.\ntype NetUNIXType uint64\n\n// NetUNIXFlags is the type of the flags field.\ntype NetUNIXFlags uint64\n\n// NetUNIXState is the type of the state field.\ntype NetUNIXState uint64\n\n// NetUNIXLine represents a line of /proc/net/unix.\ntype NetUNIXLine struct {\n\tKernelPtr string\n\tRefCount uint64\n\tProtocol uint64\n\tFlags NetUNIXFlags\n\tType NetUNIXType\n\tState NetUNIXState\n\tInode uint64\n\tPath string\n}\n\n// NetUNIX holds the data read from /proc/net/unix.\ntype NetUNIX struct {\n\tRows []*NetUNIXLine\n}\n\n// NetUNIX returns data read from /proc/net/unix.\nfunc (fs FS) NetUNIX() (*NetUNIX, error) {\n\treturn readNetUNIX(fs.proc.Path(\"net/unix\"))\n}\n\n// readNetUNIX reads data in /proc/net/unix format from the specified file.\nfunc readNetUNIX(file string) (*NetUNIX, error) {\n\t// This file could be quite large and a streaming read is desirable versus\n\t// reading the entire contents at once.\n\tf, err := os.Open(file)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer f.Close()\n\n\treturn parseNetUNIX(f)\n}\n\n// parseNetUNIX creates a NetUnix structure from the incoming stream.\nfunc parseNetUNIX(r io.Reader) (*NetUNIX, error) {\n\t// Begin scanning by checking for the existence of Inode.\n\ts := bufio.NewScanner(r)\n\ts.Scan()\n\n\t// From the man page of proc(5), it does not contain an Inode field,\n\t// but in actually it exists. This code works for both cases.\n\thasInode := strings.Contains(s.Text(), \"Inode\")\n\n\t// Expect a minimum number of fields, but Inode and Path are optional:\n\t// Num RefCount Protocol Flags Type St Inode Path\n\tminFields := 6\n\tif hasInode {\n\t\tminFields++\n\t}\n\n\tvar nu NetUNIX\n\tfor s.Scan() {\n\t\tline := s.Text()\n\t\titem, err := nu.parseLine(line, hasInode, minFields)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"failed to parse /proc/net/unix data %q: %w\", line, err)\n\t\t}\n\n\t\tnu.Rows = append(nu.Rows, item)\n\t}\n\n\tif err := s.Err(); err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to scan /proc/net/unix data: %w\", err)\n\t}\n\n\treturn &nu, nil\n}\n\nfunc (u *NetUNIX) parseLine(line string, hasInode bool, min int) (*NetUNIXLine, error) {\n\tfields := strings.Fields(line)\n\n\tl := len(fields)\n\tif l < min {\n\t\treturn nil, fmt.Errorf(\"expected at least %d fields but got %d\", min, l)\n\t}\n\n\t// Field offsets are as follows:\n\t// Num RefCount Protocol Flags Type St Inode Path\n\n\tkernelPtr := strings.TrimSuffix(fields[0], \":\")\n\n\tusers, err := u.parseUsers(fields[1])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse ref count %q: %w\", fields[1], err)\n\t}\n\n\tflags, err := u.parseFlags(fields[3])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse flags %q: %w\", fields[3], err)\n\t}\n\n\ttyp, err := u.parseType(fields[4])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse type %q: %w\", fields[4], err)\n\t}\n\n\tstate, err := u.parseState(fields[5])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse state %q: %w\", fields[5], err)\n\t}\n\n\tvar inode uint64\n\tif hasInode {\n\t\tinode, err = u.parseInode(fields[6])\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"failed to parse inode %q: %w\", fields[6], err)\n\t\t}\n\t}\n\n\tn := &NetUNIXLine{\n\t\tKernelPtr: kernelPtr,\n\t\tRefCount: users,\n\t\tType: typ,\n\t\tFlags: flags,\n\t\tState: state,\n\t\tInode: inode,\n\t}\n\n\t// Path field is optional.\n\tif l > min {\n\t\t// Path occurs at either index 6 or 7 depending on whether inode is\n\t\t// already present.\n\t\tpathIdx := 7\n\t\tif !hasInode {\n\t\t\tpathIdx--\n\t\t}\n\n\t\tn.Path = fields[pathIdx]\n\t}\n\n\treturn n, nil\n}\n\nfunc (u NetUNIX) parseUsers(s string) (uint64, error) {\n\treturn strconv.ParseUint(s, 16, 32)\n}\n\nfunc (u NetUNIX) parseType(s string) (NetUNIXType, error) {\n\ttyp, err := strconv.ParseUint(s, 16, 16)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn NetUNIXType(typ), nil\n}\n\nfunc (u NetUNIX) parseFlags(s string) (NetUNIXFlags, error) {\n\tflags, err := strconv.ParseUint(s, 16, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn NetUNIXFlags(flags), nil\n}\n\nfunc (u NetUNIX) parseState(s string) (NetUNIXState, error) {\n\tst, err := strconv.ParseInt(s, 16, 8)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn NetUNIXState(st), nil\n}\n\nfunc (u NetUNIX) parseInode(s string) (uint64, error) {\n\treturn strconv.ParseUint(s, 10, 64)\n}\n\nfunc (t NetUNIXType) String() string {\n\tswitch t {\n\tcase netUnixTypeStream:\n\t\treturn \"stream\"\n\tcase netUnixTypeDgram:\n\t\treturn \"dgram\"\n\tcase netUnixTypeSeqpacket:\n\t\treturn \"seqpacket\"\n\t}\n\treturn \"unknown\"\n}\n\nfunc (f NetUNIXFlags) String() string {\n\tswitch f {\n\tcase netUnixFlagListen:\n\t\treturn \"listen\"\n\tdefault:\n\t\treturn \"default\"\n\t}\n}\n\nfunc (s NetUNIXState) String() string {\n\tswitch s {\n\tcase netUnixStateUnconnected:\n\t\treturn \"unconnected\"\n\tcase netUnixStateConnecting:\n\t\treturn \"connecting\"\n\tcase netUnixStateConnected:\n\t\treturn \"connected\"\n\tcase netUnixStateDisconnected:\n\t\treturn \"disconnected\"\n\t}\n\treturn \"unknown\"\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/net_xfrm.go",
"content": "// Copyright 2017 Prometheus Team\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// XfrmStat models the contents of /proc/net/xfrm_stat.\ntype XfrmStat struct {\n\t// All errors which are not matched by other\n\tXfrmInError int\n\t// No buffer is left\n\tXfrmInBufferError int\n\t// Header Error\n\tXfrmInHdrError int\n\t// No state found\n\t// i.e. either inbound SPI, address, or IPSEC protocol at SA is wrong\n\tXfrmInNoStates int\n\t// Transformation protocol specific error\n\t// e.g. SA Key is wrong\n\tXfrmInStateProtoError int\n\t// Transformation mode specific error\n\tXfrmInStateModeError int\n\t// Sequence error\n\t// e.g. sequence number is out of window\n\tXfrmInStateSeqError int\n\t// State is expired\n\tXfrmInStateExpired int\n\t// State has mismatch option\n\t// e.g. UDP encapsulation type is mismatched\n\tXfrmInStateMismatch int\n\t// State is invalid\n\tXfrmInStateInvalid int\n\t// No matching template for states\n\t// e.g. Inbound SAs are correct but SP rule is wrong\n\tXfrmInTmplMismatch int\n\t// No policy is found for states\n\t// e.g. Inbound SAs are correct but no SP is found\n\tXfrmInNoPols int\n\t// Policy discards\n\tXfrmInPolBlock int\n\t// Policy error\n\tXfrmInPolError int\n\t// All errors which are not matched by others\n\tXfrmOutError int\n\t// Bundle generation error\n\tXfrmOutBundleGenError int\n\t// Bundle check error\n\tXfrmOutBundleCheckError int\n\t// No state was found\n\tXfrmOutNoStates int\n\t// Transformation protocol specific error\n\tXfrmOutStateProtoError int\n\t// Transportation mode specific error\n\tXfrmOutStateModeError int\n\t// Sequence error\n\t// i.e sequence number overflow\n\tXfrmOutStateSeqError int\n\t// State is expired\n\tXfrmOutStateExpired int\n\t// Policy discads\n\tXfrmOutPolBlock int\n\t// Policy is dead\n\tXfrmOutPolDead int\n\t// Policy Error\n\tXfrmOutPolError int\n\t// Forward routing of a packet is not allowed\n\tXfrmFwdHdrError int\n\t// State is invalid, perhaps expired\n\tXfrmOutStateInvalid int\n\t// State hasn’t been fully acquired before use\n\tXfrmAcquireError int\n}\n\n// NewXfrmStat reads the xfrm_stat statistics.\nfunc NewXfrmStat() (XfrmStat, error) {\n\tfs, err := NewFS(DefaultMountPoint)\n\tif err != nil {\n\t\treturn XfrmStat{}, err\n\t}\n\n\treturn fs.NewXfrmStat()\n}\n\n// NewXfrmStat reads the xfrm_stat statistics from the 'proc' filesystem.\nfunc (fs FS) NewXfrmStat() (XfrmStat, error) {\n\tfile, err := os.Open(fs.proc.Path(\"net/xfrm_stat\"))\n\tif err != nil {\n\t\treturn XfrmStat{}, err\n\t}\n\tdefer file.Close()\n\n\tvar (\n\t\tx = XfrmStat{}\n\t\ts = bufio.NewScanner(file)\n\t)\n\n\tfor s.Scan() {\n\t\tfields := strings.Fields(s.Text())\n\n\t\tif len(fields) != 2 {\n\t\t\treturn XfrmStat{}, fmt.Errorf(\"couldn't parse %q line %q\", file.Name(), s.Text())\n\t\t}\n\n\t\tname := fields[0]\n\t\tvalue, err := strconv.Atoi(fields[1])\n\t\tif err != nil {\n\t\t\treturn XfrmStat{}, err\n\t\t}\n\n\t\tswitch name {\n\t\tcase \"XfrmInError\":\n\t\t\tx.XfrmInError = value\n\t\tcase \"XfrmInBufferError\":\n\t\t\tx.XfrmInBufferError = value\n\t\tcase \"XfrmInHdrError\":\n\t\t\tx.XfrmInHdrError = value\n\t\tcase \"XfrmInNoStates\":\n\t\t\tx.XfrmInNoStates = value\n\t\tcase \"XfrmInStateProtoError\":\n\t\t\tx.XfrmInStateProtoError = value\n\t\tcase \"XfrmInStateModeError\":\n\t\t\tx.XfrmInStateModeError = value\n\t\tcase \"XfrmInStateSeqError\":\n\t\t\tx.XfrmInStateSeqError = value\n\t\tcase \"XfrmInStateExpired\":\n\t\t\tx.XfrmInStateExpired = value\n\t\tcase \"XfrmInStateInvalid\":\n\t\t\tx.XfrmInStateInvalid = value\n\t\tcase \"XfrmInTmplMismatch\":\n\t\t\tx.XfrmInTmplMismatch = value\n\t\tcase \"XfrmInNoPols\":\n\t\t\tx.XfrmInNoPols = value\n\t\tcase \"XfrmInPolBlock\":\n\t\t\tx.XfrmInPolBlock = value\n\t\tcase \"XfrmInPolError\":\n\t\t\tx.XfrmInPolError = value\n\t\tcase \"XfrmOutError\":\n\t\t\tx.XfrmOutError = value\n\t\tcase \"XfrmInStateMismatch\":\n\t\t\tx.XfrmInStateMismatch = value\n\t\tcase \"XfrmOutBundleGenError\":\n\t\t\tx.XfrmOutBundleGenError = value\n\t\tcase \"XfrmOutBundleCheckError\":\n\t\t\tx.XfrmOutBundleCheckError = value\n\t\tcase \"XfrmOutNoStates\":\n\t\t\tx.XfrmOutNoStates = value\n\t\tcase \"XfrmOutStateProtoError\":\n\t\t\tx.XfrmOutStateProtoError = value\n\t\tcase \"XfrmOutStateModeError\":\n\t\t\tx.XfrmOutStateModeError = value\n\t\tcase \"XfrmOutStateSeqError\":\n\t\t\tx.XfrmOutStateSeqError = value\n\t\tcase \"XfrmOutStateExpired\":\n\t\t\tx.XfrmOutStateExpired = value\n\t\tcase \"XfrmOutPolBlock\":\n\t\t\tx.XfrmOutPolBlock = value\n\t\tcase \"XfrmOutPolDead\":\n\t\t\tx.XfrmOutPolDead = value\n\t\tcase \"XfrmOutPolError\":\n\t\t\tx.XfrmOutPolError = value\n\t\tcase \"XfrmFwdHdrError\":\n\t\t\tx.XfrmFwdHdrError = value\n\t\tcase \"XfrmOutStateInvalid\":\n\t\t\tx.XfrmOutStateInvalid = value\n\t\tcase \"XfrmAcquireError\":\n\t\t\tx.XfrmAcquireError = value\n\t\t}\n\n\t}\n\n\treturn x, s.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/netstat.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// NetStat contains statistics for all the counters from one file.\ntype NetStat struct {\n\tStats map[string][]uint64\n\tFilename string\n}\n\n// NetStat retrieves stats from `/proc/net/stat/`.\nfunc (fs FS) NetStat() ([]NetStat, error) {\n\tstatFiles, err := filepath.Glob(fs.proc.Path(\"net/stat/*\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar netStatsTotal []NetStat\n\n\tfor _, filePath := range statFiles {\n\t\tfile, err := os.Open(filePath)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tnetStatFile := NetStat{\n\t\t\tFilename: filepath.Base(filePath),\n\t\t\tStats: make(map[string][]uint64),\n\t\t}\n\t\tscanner := bufio.NewScanner(file)\n\t\tscanner.Scan()\n\t\t// First string is always a header for stats\n\t\tvar headers []string\n\t\theaders = append(headers, strings.Fields(scanner.Text())...)\n\n\t\t// Other strings represent per-CPU counters\n\t\tfor scanner.Scan() {\n\t\t\tfor num, counter := range strings.Fields(scanner.Text()) {\n\t\t\t\tvalue, err := strconv.ParseUint(counter, 16, 64)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn nil, err\n\t\t\t\t}\n\t\t\t\tnetStatFile.Stats[headers[num]] = append(netStatFile.Stats[headers[num]], value)\n\t\t\t}\n\t\t}\n\t\tnetStatsTotal = append(netStatsTotal, netStatFile)\n\t}\n\treturn netStatsTotal, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/fs\"\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Proc provides information about a running process.\ntype Proc struct {\n\t// The process ID.\n\tPID int\n\n\tfs fs.FS\n}\n\n// Procs represents a list of Proc structs.\ntype Procs []Proc\n\nfunc (p Procs) Len() int { return len(p) }\nfunc (p Procs) Swap(i, j int) { p[i], p[j] = p[j], p[i] }\nfunc (p Procs) Less(i, j int) bool { return p[i].PID < p[j].PID }\n\n// Self returns a process for the current process read via /proc/self.\nfunc Self() (Proc, error) {\n\tfs, err := NewFS(DefaultMountPoint)\n\tif err != nil {\n\t\treturn Proc{}, err\n\t}\n\treturn fs.Self()\n}\n\n// NewProc returns a process for the given pid under /proc.\nfunc NewProc(pid int) (Proc, error) {\n\tfs, err := NewFS(DefaultMountPoint)\n\tif err != nil {\n\t\treturn Proc{}, err\n\t}\n\treturn fs.Proc(pid)\n}\n\n// AllProcs returns a list of all currently available processes under /proc.\nfunc AllProcs() (Procs, error) {\n\tfs, err := NewFS(DefaultMountPoint)\n\tif err != nil {\n\t\treturn Procs{}, err\n\t}\n\treturn fs.AllProcs()\n}\n\n// Self returns a process for the current process.\nfunc (fs FS) Self() (Proc, error) {\n\tp, err := os.Readlink(fs.proc.Path(\"self\"))\n\tif err != nil {\n\t\treturn Proc{}, err\n\t}\n\tpid, err := strconv.Atoi(strings.Replace(p, string(fs.proc), \"\", -1))\n\tif err != nil {\n\t\treturn Proc{}, err\n\t}\n\treturn fs.Proc(pid)\n}\n\n// NewProc returns a process for the given pid.\n//\n// Deprecated: Use fs.Proc() instead.\nfunc (fs FS) NewProc(pid int) (Proc, error) {\n\treturn fs.Proc(pid)\n}\n\n// Proc returns a process for the given pid.\nfunc (fs FS) Proc(pid int) (Proc, error) {\n\tif _, err := os.Stat(fs.proc.Path(strconv.Itoa(pid))); err != nil {\n\t\treturn Proc{}, err\n\t}\n\treturn Proc{PID: pid, fs: fs.proc}, nil\n}\n\n// AllProcs returns a list of all currently available processes.\nfunc (fs FS) AllProcs() (Procs, error) {\n\td, err := os.Open(fs.proc.Path())\n\tif err != nil {\n\t\treturn Procs{}, err\n\t}\n\tdefer d.Close()\n\n\tnames, err := d.Readdirnames(-1)\n\tif err != nil {\n\t\treturn Procs{}, fmt.Errorf(\"could not read %q: %w\", d.Name(), err)\n\t}\n\n\tp := Procs{}\n\tfor _, n := range names {\n\t\tpid, err := strconv.ParseInt(n, 10, 64)\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\tp = append(p, Proc{PID: int(pid), fs: fs.proc})\n\t}\n\n\treturn p, nil\n}\n\n// CmdLine returns the command line of a process.\nfunc (p Proc) CmdLine() ([]string, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"cmdline\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tif len(data) < 1 {\n\t\treturn []string{}, nil\n\t}\n\n\treturn strings.Split(string(bytes.TrimRight(data, string(\"\\x00\"))), string(byte(0))), nil\n}\n\n// Wchan returns the wchan (wait channel) of a process.\nfunc (p Proc) Wchan() (string, error) {\n\tf, err := os.Open(p.path(\"wchan\"))\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\tdefer f.Close()\n\n\tdata, err := io.ReadAll(f)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\n\twchan := string(data)\n\tif wchan == \"\" || wchan == \"0\" {\n\t\treturn \"\", nil\n\t}\n\n\treturn wchan, nil\n}\n\n// Comm returns the command name of a process.\nfunc (p Proc) Comm() (string, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"comm\"))\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\n\treturn strings.TrimSpace(string(data)), nil\n}\n\n// Executable returns the absolute path of the executable command of a process.\nfunc (p Proc) Executable() (string, error) {\n\texe, err := os.Readlink(p.path(\"exe\"))\n\tif os.IsNotExist(err) {\n\t\treturn \"\", nil\n\t}\n\n\treturn exe, err\n}\n\n// Cwd returns the absolute path to the current working directory of the process.\nfunc (p Proc) Cwd() (string, error) {\n\twd, err := os.Readlink(p.path(\"cwd\"))\n\tif os.IsNotExist(err) {\n\t\treturn \"\", nil\n\t}\n\n\treturn wd, err\n}\n\n// RootDir returns the absolute path to the process's root directory (as set by chroot).\nfunc (p Proc) RootDir() (string, error) {\n\trdir, err := os.Readlink(p.path(\"root\"))\n\tif os.IsNotExist(err) {\n\t\treturn \"\", nil\n\t}\n\n\treturn rdir, err\n}\n\n// FileDescriptors returns the currently open file descriptors of a process.\nfunc (p Proc) FileDescriptors() ([]uintptr, error) {\n\tnames, err := p.fileDescriptors()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tfds := make([]uintptr, len(names))\n\tfor i, n := range names {\n\t\tfd, err := strconv.ParseInt(n, 10, 32)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"could not parse fd %q: %w\", n, err)\n\t\t}\n\t\tfds[i] = uintptr(fd)\n\t}\n\n\treturn fds, nil\n}\n\n// FileDescriptorTargets returns the targets of all file descriptors of a process.\n// If a file descriptor is not a symlink to a file (like a socket), that value will be the empty string.\nfunc (p Proc) FileDescriptorTargets() ([]string, error) {\n\tnames, err := p.fileDescriptors()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\ttargets := make([]string, len(names))\n\n\tfor i, name := range names {\n\t\ttarget, err := os.Readlink(p.path(\"fd\", name))\n\t\tif err == nil {\n\t\t\ttargets[i] = target\n\t\t}\n\t}\n\n\treturn targets, nil\n}\n\n// FileDescriptorsLen returns the number of currently open file descriptors of\n// a process.\nfunc (p Proc) FileDescriptorsLen() (int, error) {\n\tfds, err := p.fileDescriptors()\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn len(fds), nil\n}\n\n// MountStats retrieves statistics and configuration for mount points in a\n// process's namespace.\nfunc (p Proc) MountStats() ([]*Mount, error) {\n\tf, err := os.Open(p.path(\"mountstats\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer f.Close()\n\n\treturn parseMountStats(f)\n}\n\n// MountInfo retrieves mount information for mount points in a\n// process's namespace.\n// It supplies information missing in `/proc/self/mounts` and\n// fixes various other problems with that file too.\nfunc (p Proc) MountInfo() ([]*MountInfo, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"mountinfo\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseMountInfo(data)\n}\n\nfunc (p Proc) fileDescriptors() ([]string, error) {\n\td, err := os.Open(p.path(\"fd\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer d.Close()\n\n\tnames, err := d.Readdirnames(-1)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"could not read %q: %w\", d.Name(), err)\n\t}\n\n\treturn names, nil\n}\n\nfunc (p Proc) path(pa ...string) string {\n\treturn p.fs.Path(append([]string{strconv.Itoa(p.PID)}, pa...)...)\n}\n\n// FileDescriptorsInfo retrieves information about all file descriptors of\n// the process.\nfunc (p Proc) FileDescriptorsInfo() (ProcFDInfos, error) {\n\tnames, err := p.fileDescriptors()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar fdinfos ProcFDInfos\n\n\tfor _, n := range names {\n\t\tfdinfo, err := p.FDInfo(n)\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\tfdinfos = append(fdinfos, *fdinfo)\n\t}\n\n\treturn fdinfos, nil\n}\n\n// Schedstat returns task scheduling information for the process.\nfunc (p Proc) Schedstat() (ProcSchedstat, error) {\n\tcontents, err := os.ReadFile(p.path(\"schedstat\"))\n\tif err != nil {\n\t\treturn ProcSchedstat{}, err\n\t}\n\treturn parseProcSchedstat(string(contents))\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_cgroup.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Cgroup models one line from /proc/[pid]/cgroup. Each Cgroup struct describes the the placement of a PID inside a\n// specific control hierarchy. The kernel has two cgroup APIs, v1 and v2. v1 has one hierarchy per available resource\n// controller, while v2 has one unified hierarchy shared by all controllers. Regardless of v1 or v2, all hierarchies\n// contain all running processes, so the question answerable with a Cgroup struct is 'where is this process in\n// this hierarchy' (where==what path on the specific cgroupfs). By prefixing this path with the mount point of\n// *this specific* hierarchy, you can locate the relevant pseudo-files needed to read/set the data for this PID\n// in this hierarchy\n//\n// Also see http://man7.org/linux/man-pages/man7/cgroups.7.html\ntype Cgroup struct {\n\t// HierarchyID that can be matched to a named hierarchy using /proc/cgroups. Cgroups V2 only has one\n\t// hierarchy, so HierarchyID is always 0. For cgroups v1 this is a unique ID number\n\tHierarchyID int\n\t// Controllers using this hierarchy of processes. Controllers are also known as subsystems. For\n\t// Cgroups V2 this may be empty, as all active controllers use the same hierarchy\n\tControllers []string\n\t// Path of this control group, relative to the mount point of the cgroupfs representing this specific\n\t// hierarchy\n\tPath string\n}\n\n// parseCgroupString parses each line of the /proc/[pid]/cgroup file\n// Line format is hierarchyID:[controller1,controller2]:path.\nfunc parseCgroupString(cgroupStr string) (*Cgroup, error) {\n\tvar err error\n\n\tfields := strings.SplitN(cgroupStr, \":\", 3)\n\tif len(fields) < 3 {\n\t\treturn nil, fmt.Errorf(\"at least 3 fields required, found %d fields in cgroup string: %s\", len(fields), cgroupStr)\n\t}\n\n\tcgroup := &Cgroup{\n\t\tPath: fields[2],\n\t\tControllers: nil,\n\t}\n\tcgroup.HierarchyID, err = strconv.Atoi(fields[0])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse hierarchy ID\")\n\t}\n\tif fields[1] != \"\" {\n\t\tssNames := strings.Split(fields[1], \",\")\n\t\tcgroup.Controllers = append(cgroup.Controllers, ssNames...)\n\t}\n\treturn cgroup, nil\n}\n\n// parseCgroups reads each line of the /proc/[pid]/cgroup file.\nfunc parseCgroups(data []byte) ([]Cgroup, error) {\n\tvar cgroups []Cgroup\n\tscanner := bufio.NewScanner(bytes.NewReader(data))\n\tfor scanner.Scan() {\n\t\tmountString := scanner.Text()\n\t\tparsedMounts, err := parseCgroupString(mountString)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tcgroups = append(cgroups, *parsedMounts)\n\t}\n\n\terr := scanner.Err()\n\treturn cgroups, err\n}\n\n// Cgroups reads from /proc//cgroups and returns a []*Cgroup struct locating this PID in each process\n// control hierarchy running on this system. On every system (v1 and v2), all hierarchies contain all processes,\n// so the len of the returned struct is equal to the number of active hierarchies on this system.\nfunc (p Proc) Cgroups() ([]Cgroup, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"cgroup\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseCgroups(data)\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_cgroups.go",
"content": "// Copyright 2021 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// CgroupSummary models one line from /proc/cgroups.\n// This file contains information about the controllers that are compiled into the kernel.\n//\n// Also see http://man7.org/linux/man-pages/man7/cgroups.7.html\ntype CgroupSummary struct {\n\t// The name of the controller. controller is also known as subsystem.\n\tSubsysName string\n\t// The unique ID of the cgroup hierarchy on which this controller is mounted.\n\tHierarchy int\n\t// The number of control groups in this hierarchy using this controller.\n\tCgroups int\n\t// This field contains the value 1 if this controller is enabled, or 0 if it has been disabled\n\tEnabled int\n}\n\n// parseCgroupSummary parses each line of the /proc/cgroup file\n// Line format is `subsys_name\thierarchy\tnum_cgroups\tenabled`.\nfunc parseCgroupSummaryString(CgroupSummaryStr string) (*CgroupSummary, error) {\n\tvar err error\n\n\tfields := strings.Fields(CgroupSummaryStr)\n\t// require at least 4 fields\n\tif len(fields) < 4 {\n\t\treturn nil, fmt.Errorf(\"at least 4 fields required, found %d fields in cgroup info string: %s\", len(fields), CgroupSummaryStr)\n\t}\n\n\tCgroupSummary := &CgroupSummary{\n\t\tSubsysName: fields[0],\n\t}\n\tCgroupSummary.Hierarchy, err = strconv.Atoi(fields[1])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse hierarchy ID\")\n\t}\n\tCgroupSummary.Cgroups, err = strconv.Atoi(fields[2])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse Cgroup Num\")\n\t}\n\tCgroupSummary.Enabled, err = strconv.Atoi(fields[3])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to parse Enabled\")\n\t}\n\treturn CgroupSummary, nil\n}\n\n// parseCgroupSummary reads each line of the /proc/cgroup file.\nfunc parseCgroupSummary(data []byte) ([]CgroupSummary, error) {\n\tvar CgroupSummarys []CgroupSummary\n\tscanner := bufio.NewScanner(bytes.NewReader(data))\n\tfor scanner.Scan() {\n\t\tCgroupSummaryString := scanner.Text()\n\t\t// ignore comment lines\n\t\tif strings.HasPrefix(CgroupSummaryString, \"#\") {\n\t\t\tcontinue\n\t\t}\n\t\tCgroupSummary, err := parseCgroupSummaryString(CgroupSummaryString)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tCgroupSummarys = append(CgroupSummarys, *CgroupSummary)\n\t}\n\n\terr := scanner.Err()\n\treturn CgroupSummarys, err\n}\n\n// CgroupSummarys returns information about current /proc/cgroups.\nfunc (fs FS) CgroupSummarys() ([]CgroupSummary, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"cgroups\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseCgroupSummary(data)\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_environ.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Environ reads process environments from `/proc//environ`.\nfunc (p Proc) Environ() ([]string, error) {\n\tenvironments := make([]string, 0)\n\n\tdata, err := util.ReadFileNoStat(p.path(\"environ\"))\n\tif err != nil {\n\t\treturn environments, err\n\t}\n\n\tenvironments = strings.Split(string(data), \"\\000\")\n\tif len(environments) > 0 {\n\t\tenvironments = environments[:len(environments)-1]\n\t}\n\n\treturn environments, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_fdinfo.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"regexp\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\nvar (\n\trPos = regexp.MustCompile(`^pos:\\s+(\\d+)$`)\n\trFlags = regexp.MustCompile(`^flags:\\s+(\\d+)$`)\n\trMntID = regexp.MustCompile(`^mnt_id:\\s+(\\d+)$`)\n\trInotify = regexp.MustCompile(`^inotify`)\n\trInotifyParts = regexp.MustCompile(`^inotify\\s+wd:([0-9a-f]+)\\s+ino:([0-9a-f]+)\\s+sdev:([0-9a-f]+)(?:\\s+mask:([0-9a-f]+))?`)\n)\n\n// ProcFDInfo contains represents file descriptor information.\ntype ProcFDInfo struct {\n\t// File descriptor\n\tFD string\n\t// File offset\n\tPos string\n\t// File access mode and status flags\n\tFlags string\n\t// Mount point ID\n\tMntID string\n\t// List of inotify lines (structured) in the fdinfo file (kernel 3.8+ only)\n\tInotifyInfos []InotifyInfo\n}\n\n// FDInfo constructor. On kernels older than 3.8, InotifyInfos will always be empty.\nfunc (p Proc) FDInfo(fd string) (*ProcFDInfo, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"fdinfo\", fd))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar text, pos, flags, mntid string\n\tvar inotify []InotifyInfo\n\n\tscanner := bufio.NewScanner(bytes.NewReader(data))\n\tfor scanner.Scan() {\n\t\ttext = scanner.Text()\n\t\tif rPos.MatchString(text) {\n\t\t\tpos = rPos.FindStringSubmatch(text)[1]\n\t\t} else if rFlags.MatchString(text) {\n\t\t\tflags = rFlags.FindStringSubmatch(text)[1]\n\t\t} else if rMntID.MatchString(text) {\n\t\t\tmntid = rMntID.FindStringSubmatch(text)[1]\n\t\t} else if rInotify.MatchString(text) {\n\t\t\tnewInotify, err := parseInotifyInfo(text)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tinotify = append(inotify, *newInotify)\n\t\t}\n\t}\n\n\ti := &ProcFDInfo{\n\t\tFD: fd,\n\t\tPos: pos,\n\t\tFlags: flags,\n\t\tMntID: mntid,\n\t\tInotifyInfos: inotify,\n\t}\n\n\treturn i, nil\n}\n\n// InotifyInfo represents a single inotify line in the fdinfo file.\ntype InotifyInfo struct {\n\t// Watch descriptor number\n\tWD string\n\t// Inode number\n\tIno string\n\t// Device ID\n\tSdev string\n\t// Mask of events being monitored\n\tMask string\n}\n\n// InotifyInfo constructor. Only available on kernel 3.8+.\nfunc parseInotifyInfo(line string) (*InotifyInfo, error) {\n\tm := rInotifyParts.FindStringSubmatch(line)\n\tif len(m) >= 4 {\n\t\tvar mask string\n\t\tif len(m) == 5 {\n\t\t\tmask = m[4]\n\t\t}\n\t\ti := &InotifyInfo{\n\t\t\tWD: m[1],\n\t\t\tIno: m[2],\n\t\t\tSdev: m[3],\n\t\t\tMask: mask,\n\t\t}\n\t\treturn i, nil\n\t}\n\treturn nil, fmt.Errorf(\"invalid inode entry: %q\", line)\n}\n\n// ProcFDInfos represents a list of ProcFDInfo structs.\ntype ProcFDInfos []ProcFDInfo\n\nfunc (p ProcFDInfos) Len() int { return len(p) }\nfunc (p ProcFDInfos) Swap(i, j int) { p[i], p[j] = p[j], p[i] }\nfunc (p ProcFDInfos) Less(i, j int) bool { return p[i].FD < p[j].FD }\n\n// InotifyWatchLen returns the total number of inotify watches.\nfunc (p ProcFDInfos) InotifyWatchLen() (int, error) {\n\tlength := 0\n\tfor _, f := range p {\n\t\tlength += len(f.InotifyInfos)\n\t}\n\n\treturn length, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_io.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// ProcIO models the content of /proc//io.\ntype ProcIO struct {\n\t// Chars read.\n\tRChar uint64\n\t// Chars written.\n\tWChar uint64\n\t// Read syscalls.\n\tSyscR uint64\n\t// Write syscalls.\n\tSyscW uint64\n\t// Bytes read.\n\tReadBytes uint64\n\t// Bytes written.\n\tWriteBytes uint64\n\t// Bytes written, but taking into account truncation. See\n\t// Documentation/filesystems/proc.txt in the kernel sources for\n\t// detailed explanation.\n\tCancelledWriteBytes int64\n}\n\n// IO creates a new ProcIO instance from a given Proc instance.\nfunc (p Proc) IO() (ProcIO, error) {\n\tpio := ProcIO{}\n\n\tdata, err := util.ReadFileNoStat(p.path(\"io\"))\n\tif err != nil {\n\t\treturn pio, err\n\t}\n\n\tioFormat := \"rchar: %d\\nwchar: %d\\nsyscr: %d\\nsyscw: %d\\n\" +\n\t\t\"read_bytes: %d\\nwrite_bytes: %d\\n\" +\n\t\t\"cancelled_write_bytes: %d\\n\"\n\n\t_, err = fmt.Sscanf(string(data), ioFormat, &pio.RChar, &pio.WChar, &pio.SyscR,\n\t\t&pio.SyscW, &pio.ReadBytes, &pio.WriteBytes, &pio.CancelledWriteBytes)\n\n\treturn pio, err\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_limits.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strconv\"\n)\n\n// ProcLimits represents the soft limits for each of the process's resource\n// limits. For more information see getrlimit(2):\n// http://man7.org/linux/man-pages/man2/getrlimit.2.html.\ntype ProcLimits struct {\n\t// CPU time limit in seconds.\n\tCPUTime uint64\n\t// Maximum size of files that the process may create.\n\tFileSize uint64\n\t// Maximum size of the process's data segment (initialized data,\n\t// uninitialized data, and heap).\n\tDataSize uint64\n\t// Maximum size of the process stack in bytes.\n\tStackSize uint64\n\t// Maximum size of a core file.\n\tCoreFileSize uint64\n\t// Limit of the process's resident set in pages.\n\tResidentSet uint64\n\t// Maximum number of processes that can be created for the real user ID of\n\t// the calling process.\n\tProcesses uint64\n\t// Value one greater than the maximum file descriptor number that can be\n\t// opened by this process.\n\tOpenFiles uint64\n\t// Maximum number of bytes of memory that may be locked into RAM.\n\tLockedMemory uint64\n\t// Maximum size of the process's virtual memory address space in bytes.\n\tAddressSpace uint64\n\t// Limit on the combined number of flock(2) locks and fcntl(2) leases that\n\t// this process may establish.\n\tFileLocks uint64\n\t// Limit of signals that may be queued for the real user ID of the calling\n\t// process.\n\tPendingSignals uint64\n\t// Limit on the number of bytes that can be allocated for POSIX message\n\t// queues for the real user ID of the calling process.\n\tMsqqueueSize uint64\n\t// Limit of the nice priority set using setpriority(2) or nice(2).\n\tNicePriority uint64\n\t// Limit of the real-time priority set using sched_setscheduler(2) or\n\t// sched_setparam(2).\n\tRealtimePriority uint64\n\t// Limit (in microseconds) on the amount of CPU time that a process\n\t// scheduled under a real-time scheduling policy may consume without making\n\t// a blocking system call.\n\tRealtimeTimeout uint64\n}\n\nconst (\n\tlimitsFields = 4\n\tlimitsUnlimited = \"unlimited\"\n)\n\nvar (\n\tlimitsMatch = regexp.MustCompile(`(Max \\w+\\s{0,1}?\\w*\\s{0,1}\\w*)\\s{2,}(\\w+)\\s+(\\w+)`)\n)\n\n// NewLimits returns the current soft limits of the process.\n//\n// Deprecated: Use p.Limits() instead.\nfunc (p Proc) NewLimits() (ProcLimits, error) {\n\treturn p.Limits()\n}\n\n// Limits returns the current soft limits of the process.\nfunc (p Proc) Limits() (ProcLimits, error) {\n\tf, err := os.Open(p.path(\"limits\"))\n\tif err != nil {\n\t\treturn ProcLimits{}, err\n\t}\n\tdefer f.Close()\n\n\tvar (\n\t\tl = ProcLimits{}\n\t\ts = bufio.NewScanner(f)\n\t)\n\n\ts.Scan() // Skip limits header\n\n\tfor s.Scan() {\n\t\t//fields := limitsMatch.Split(s.Text(), limitsFields)\n\t\tfields := limitsMatch.FindStringSubmatch(s.Text())\n\t\tif len(fields) != limitsFields {\n\t\t\treturn ProcLimits{}, fmt.Errorf(\"couldn't parse %q line %q\", f.Name(), s.Text())\n\t\t}\n\n\t\tswitch fields[1] {\n\t\tcase \"Max cpu time\":\n\t\t\tl.CPUTime, err = parseUint(fields[2])\n\t\tcase \"Max file size\":\n\t\t\tl.FileSize, err = parseUint(fields[2])\n\t\tcase \"Max data size\":\n\t\t\tl.DataSize, err = parseUint(fields[2])\n\t\tcase \"Max stack size\":\n\t\t\tl.StackSize, err = parseUint(fields[2])\n\t\tcase \"Max core file size\":\n\t\t\tl.CoreFileSize, err = parseUint(fields[2])\n\t\tcase \"Max resident set\":\n\t\t\tl.ResidentSet, err = parseUint(fields[2])\n\t\tcase \"Max processes\":\n\t\t\tl.Processes, err = parseUint(fields[2])\n\t\tcase \"Max open files\":\n\t\t\tl.OpenFiles, err = parseUint(fields[2])\n\t\tcase \"Max locked memory\":\n\t\t\tl.LockedMemory, err = parseUint(fields[2])\n\t\tcase \"Max address space\":\n\t\t\tl.AddressSpace, err = parseUint(fields[2])\n\t\tcase \"Max file locks\":\n\t\t\tl.FileLocks, err = parseUint(fields[2])\n\t\tcase \"Max pending signals\":\n\t\t\tl.PendingSignals, err = parseUint(fields[2])\n\t\tcase \"Max msgqueue size\":\n\t\t\tl.MsqqueueSize, err = parseUint(fields[2])\n\t\tcase \"Max nice priority\":\n\t\t\tl.NicePriority, err = parseUint(fields[2])\n\t\tcase \"Max realtime priority\":\n\t\t\tl.RealtimePriority, err = parseUint(fields[2])\n\t\tcase \"Max realtime timeout\":\n\t\t\tl.RealtimeTimeout, err = parseUint(fields[2])\n\t\t}\n\t\tif err != nil {\n\t\t\treturn ProcLimits{}, err\n\t\t}\n\t}\n\n\treturn l, s.Err()\n}\n\nfunc parseUint(s string) (uint64, error) {\n\tif s == limitsUnlimited {\n\t\treturn 18446744073709551615, nil\n\t}\n\ti, err := strconv.ParseUint(s, 10, 64)\n\tif err != nil {\n\t\treturn 0, fmt.Errorf(\"couldn't parse value %q: %w\", s, err)\n\t}\n\treturn i, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_maps.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris) && !js\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris\n// +build !js\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"golang.org/x/sys/unix\"\n)\n\n// ProcMapPermissions contains permission settings read from `/proc/[pid]/maps`.\ntype ProcMapPermissions struct {\n\t// mapping has the [R]ead flag set\n\tRead bool\n\t// mapping has the [W]rite flag set\n\tWrite bool\n\t// mapping has the [X]ecutable flag set\n\tExecute bool\n\t// mapping has the [S]hared flag set\n\tShared bool\n\t// mapping is marked as [P]rivate (copy on write)\n\tPrivate bool\n}\n\n// ProcMap contains the process memory-mappings of the process\n// read from `/proc/[pid]/maps`.\ntype ProcMap struct {\n\t// The start address of current mapping.\n\tStartAddr uintptr\n\t// The end address of the current mapping\n\tEndAddr uintptr\n\t// The permissions for this mapping\n\tPerms *ProcMapPermissions\n\t// The current offset into the file/fd (e.g., shared libs)\n\tOffset int64\n\t// Device owner of this mapping (major:minor) in Mkdev format.\n\tDev uint64\n\t// The inode of the device above\n\tInode uint64\n\t// The file or psuedofile (or empty==anonymous)\n\tPathname string\n}\n\n// parseDevice parses the device token of a line and converts it to a dev_t\n// (mkdev) like structure.\nfunc parseDevice(s string) (uint64, error) {\n\ttoks := strings.Split(s, \":\")\n\tif len(toks) < 2 {\n\t\treturn 0, fmt.Errorf(\"unexpected number of fields\")\n\t}\n\n\tmajor, err := strconv.ParseUint(toks[0], 16, 0)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\tminor, err := strconv.ParseUint(toks[1], 16, 0)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn unix.Mkdev(uint32(major), uint32(minor)), nil\n}\n\n// parseAddress converts a hex-string to a uintptr.\nfunc parseAddress(s string) (uintptr, error) {\n\ta, err := strconv.ParseUint(s, 16, 0)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\treturn uintptr(a), nil\n}\n\n// parseAddresses parses the start-end address.\nfunc parseAddresses(s string) (uintptr, uintptr, error) {\n\ttoks := strings.Split(s, \"-\")\n\tif len(toks) < 2 {\n\t\treturn 0, 0, fmt.Errorf(\"invalid address\")\n\t}\n\n\tsaddr, err := parseAddress(toks[0])\n\tif err != nil {\n\t\treturn 0, 0, err\n\t}\n\n\teaddr, err := parseAddress(toks[1])\n\tif err != nil {\n\t\treturn 0, 0, err\n\t}\n\n\treturn saddr, eaddr, nil\n}\n\n// parsePermissions parses a token and returns any that are set.\nfunc parsePermissions(s string) (*ProcMapPermissions, error) {\n\tif len(s) < 4 {\n\t\treturn nil, fmt.Errorf(\"invalid permissions token\")\n\t}\n\n\tperms := ProcMapPermissions{}\n\tfor _, ch := range s {\n\t\tswitch ch {\n\t\tcase 'r':\n\t\t\tperms.Read = true\n\t\tcase 'w':\n\t\t\tperms.Write = true\n\t\tcase 'x':\n\t\t\tperms.Execute = true\n\t\tcase 'p':\n\t\t\tperms.Private = true\n\t\tcase 's':\n\t\t\tperms.Shared = true\n\t\t}\n\t}\n\n\treturn &perms, nil\n}\n\n// parseProcMap will attempt to parse a single line within a proc/[pid]/maps\n// buffer.\nfunc parseProcMap(text string) (*ProcMap, error) {\n\tfields := strings.Fields(text)\n\tif len(fields) < 5 {\n\t\treturn nil, fmt.Errorf(\"truncated procmap entry\")\n\t}\n\n\tsaddr, eaddr, err := parseAddresses(fields[0])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tperms, err := parsePermissions(fields[1])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\toffset, err := strconv.ParseInt(fields[2], 16, 0)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tdevice, err := parseDevice(fields[3])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tinode, err := strconv.ParseUint(fields[4], 10, 0)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tpathname := \"\"\n\n\tif len(fields) >= 5 {\n\t\tpathname = strings.Join(fields[5:], \" \")\n\t}\n\n\treturn &ProcMap{\n\t\tStartAddr: saddr,\n\t\tEndAddr: eaddr,\n\t\tPerms: perms,\n\t\tOffset: offset,\n\t\tDev: device,\n\t\tInode: inode,\n\t\tPathname: pathname,\n\t}, nil\n}\n\n// ProcMaps reads from /proc/[pid]/maps to get the memory-mappings of the\n// process.\nfunc (p Proc) ProcMaps() ([]*ProcMap, error) {\n\tfile, err := os.Open(p.path(\"maps\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer file.Close()\n\n\tmaps := []*ProcMap{}\n\tscan := bufio.NewScanner(file)\n\n\tfor scan.Scan() {\n\t\tm, err := parseProcMap(scan.Text())\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tmaps = append(maps, m)\n\t}\n\n\treturn maps, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_netstat.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// ProcNetstat models the content of /proc//net/netstat.\ntype ProcNetstat struct {\n\t// The process ID.\n\tPID int\n\tTcpExt\n\tIpExt\n}\n\ntype TcpExt struct { // nolint:revive\n\tSyncookiesSent float64\n\tSyncookiesRecv float64\n\tSyncookiesFailed float64\n\tEmbryonicRsts float64\n\tPruneCalled float64\n\tRcvPruned float64\n\tOfoPruned float64\n\tOutOfWindowIcmps float64\n\tLockDroppedIcmps float64\n\tArpFilter float64\n\tTW float64\n\tTWRecycled float64\n\tTWKilled float64\n\tPAWSActive float64\n\tPAWSEstab float64\n\tDelayedACKs float64\n\tDelayedACKLocked float64\n\tDelayedACKLost float64\n\tListenOverflows float64\n\tListenDrops float64\n\tTCPHPHits float64\n\tTCPPureAcks float64\n\tTCPHPAcks float64\n\tTCPRenoRecovery float64\n\tTCPSackRecovery float64\n\tTCPSACKReneging float64\n\tTCPSACKReorder float64\n\tTCPRenoReorder float64\n\tTCPTSReorder float64\n\tTCPFullUndo float64\n\tTCPPartialUndo float64\n\tTCPDSACKUndo float64\n\tTCPLossUndo float64\n\tTCPLostRetransmit float64\n\tTCPRenoFailures float64\n\tTCPSackFailures float64\n\tTCPLossFailures float64\n\tTCPFastRetrans float64\n\tTCPSlowStartRetrans float64\n\tTCPTimeouts float64\n\tTCPLossProbes float64\n\tTCPLossProbeRecovery float64\n\tTCPRenoRecoveryFail float64\n\tTCPSackRecoveryFail float64\n\tTCPRcvCollapsed float64\n\tTCPDSACKOldSent float64\n\tTCPDSACKOfoSent float64\n\tTCPDSACKRecv float64\n\tTCPDSACKOfoRecv float64\n\tTCPAbortOnData float64\n\tTCPAbortOnClose float64\n\tTCPAbortOnMemory float64\n\tTCPAbortOnTimeout float64\n\tTCPAbortOnLinger float64\n\tTCPAbortFailed float64\n\tTCPMemoryPressures float64\n\tTCPMemoryPressuresChrono float64\n\tTCPSACKDiscard float64\n\tTCPDSACKIgnoredOld float64\n\tTCPDSACKIgnoredNoUndo float64\n\tTCPSpuriousRTOs float64\n\tTCPMD5NotFound float64\n\tTCPMD5Unexpected float64\n\tTCPMD5Failure float64\n\tTCPSackShifted float64\n\tTCPSackMerged float64\n\tTCPSackShiftFallback float64\n\tTCPBacklogDrop float64\n\tPFMemallocDrop float64\n\tTCPMinTTLDrop float64\n\tTCPDeferAcceptDrop float64\n\tIPReversePathFilter float64\n\tTCPTimeWaitOverflow float64\n\tTCPReqQFullDoCookies float64\n\tTCPReqQFullDrop float64\n\tTCPRetransFail float64\n\tTCPRcvCoalesce float64\n\tTCPOFOQueue float64\n\tTCPOFODrop float64\n\tTCPOFOMerge float64\n\tTCPChallengeACK float64\n\tTCPSYNChallenge float64\n\tTCPFastOpenActive float64\n\tTCPFastOpenActiveFail float64\n\tTCPFastOpenPassive float64\n\tTCPFastOpenPassiveFail float64\n\tTCPFastOpenListenOverflow float64\n\tTCPFastOpenCookieReqd float64\n\tTCPFastOpenBlackhole float64\n\tTCPSpuriousRtxHostQueues float64\n\tBusyPollRxPackets float64\n\tTCPAutoCorking float64\n\tTCPFromZeroWindowAdv float64\n\tTCPToZeroWindowAdv float64\n\tTCPWantZeroWindowAdv float64\n\tTCPSynRetrans float64\n\tTCPOrigDataSent float64\n\tTCPHystartTrainDetect float64\n\tTCPHystartTrainCwnd float64\n\tTCPHystartDelayDetect float64\n\tTCPHystartDelayCwnd float64\n\tTCPACKSkippedSynRecv float64\n\tTCPACKSkippedPAWS float64\n\tTCPACKSkippedSeq float64\n\tTCPACKSkippedFinWait2 float64\n\tTCPACKSkippedTimeWait float64\n\tTCPACKSkippedChallenge float64\n\tTCPWinProbe float64\n\tTCPKeepAlive float64\n\tTCPMTUPFail float64\n\tTCPMTUPSuccess float64\n\tTCPWqueueTooBig float64\n}\n\ntype IpExt struct { // nolint:revive\n\tInNoRoutes float64\n\tInTruncatedPkts float64\n\tInMcastPkts float64\n\tOutMcastPkts float64\n\tInBcastPkts float64\n\tOutBcastPkts float64\n\tInOctets float64\n\tOutOctets float64\n\tInMcastOctets float64\n\tOutMcastOctets float64\n\tInBcastOctets float64\n\tOutBcastOctets float64\n\tInCsumErrors float64\n\tInNoECTPkts float64\n\tInECT1Pkts float64\n\tInECT0Pkts float64\n\tInCEPkts float64\n\tReasmOverlaps float64\n}\n\nfunc (p Proc) Netstat() (ProcNetstat, error) {\n\tfilename := p.path(\"net/netstat\")\n\tdata, err := util.ReadFileNoStat(filename)\n\tif err != nil {\n\t\treturn ProcNetstat{PID: p.PID}, err\n\t}\n\tprocNetstat, err := parseNetstat(bytes.NewReader(data), filename)\n\tprocNetstat.PID = p.PID\n\treturn procNetstat, err\n}\n\n// parseNetstat parses the metrics from proc//net/netstat file\n// and returns a ProcNetstat structure.\nfunc parseNetstat(r io.Reader, fileName string) (ProcNetstat, error) {\n\tvar (\n\t\tscanner = bufio.NewScanner(r)\n\t\tprocNetstat = ProcNetstat{}\n\t)\n\n\tfor scanner.Scan() {\n\t\tnameParts := strings.Split(scanner.Text(), \" \")\n\t\tscanner.Scan()\n\t\tvalueParts := strings.Split(scanner.Text(), \" \")\n\t\t// Remove trailing :.\n\t\tprotocol := strings.TrimSuffix(nameParts[0], \":\")\n\t\tif len(nameParts) != len(valueParts) {\n\t\t\treturn procNetstat, fmt.Errorf(\"mismatch field count mismatch in %s: %s\",\n\t\t\t\tfileName, protocol)\n\t\t}\n\t\tfor i := 1; i < len(nameParts); i++ {\n\t\t\tvalue, err := strconv.ParseFloat(valueParts[i], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn procNetstat, err\n\t\t\t}\n\t\t\tkey := nameParts[i]\n\n\t\t\tswitch protocol {\n\t\t\tcase \"TcpExt\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"SyncookiesSent\":\n\t\t\t\t\tprocNetstat.TcpExt.SyncookiesSent = value\n\t\t\t\tcase \"SyncookiesRecv\":\n\t\t\t\t\tprocNetstat.TcpExt.SyncookiesRecv = value\n\t\t\t\tcase \"SyncookiesFailed\":\n\t\t\t\t\tprocNetstat.TcpExt.SyncookiesFailed = value\n\t\t\t\tcase \"EmbryonicRsts\":\n\t\t\t\t\tprocNetstat.TcpExt.EmbryonicRsts = value\n\t\t\t\tcase \"PruneCalled\":\n\t\t\t\t\tprocNetstat.TcpExt.PruneCalled = value\n\t\t\t\tcase \"RcvPruned\":\n\t\t\t\t\tprocNetstat.TcpExt.RcvPruned = value\n\t\t\t\tcase \"OfoPruned\":\n\t\t\t\t\tprocNetstat.TcpExt.OfoPruned = value\n\t\t\t\tcase \"OutOfWindowIcmps\":\n\t\t\t\t\tprocNetstat.TcpExt.OutOfWindowIcmps = value\n\t\t\t\tcase \"LockDroppedIcmps\":\n\t\t\t\t\tprocNetstat.TcpExt.LockDroppedIcmps = value\n\t\t\t\tcase \"ArpFilter\":\n\t\t\t\t\tprocNetstat.TcpExt.ArpFilter = value\n\t\t\t\tcase \"TW\":\n\t\t\t\t\tprocNetstat.TcpExt.TW = value\n\t\t\t\tcase \"TWRecycled\":\n\t\t\t\t\tprocNetstat.TcpExt.TWRecycled = value\n\t\t\t\tcase \"TWKilled\":\n\t\t\t\t\tprocNetstat.TcpExt.TWKilled = value\n\t\t\t\tcase \"PAWSActive\":\n\t\t\t\t\tprocNetstat.TcpExt.PAWSActive = value\n\t\t\t\tcase \"PAWSEstab\":\n\t\t\t\t\tprocNetstat.TcpExt.PAWSEstab = value\n\t\t\t\tcase \"DelayedACKs\":\n\t\t\t\t\tprocNetstat.TcpExt.DelayedACKs = value\n\t\t\t\tcase \"DelayedACKLocked\":\n\t\t\t\t\tprocNetstat.TcpExt.DelayedACKLocked = value\n\t\t\t\tcase \"DelayedACKLost\":\n\t\t\t\t\tprocNetstat.TcpExt.DelayedACKLost = value\n\t\t\t\tcase \"ListenOverflows\":\n\t\t\t\t\tprocNetstat.TcpExt.ListenOverflows = value\n\t\t\t\tcase \"ListenDrops\":\n\t\t\t\t\tprocNetstat.TcpExt.ListenDrops = value\n\t\t\t\tcase \"TCPHPHits\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHPHits = value\n\t\t\t\tcase \"TCPPureAcks\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPPureAcks = value\n\t\t\t\tcase \"TCPHPAcks\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHPAcks = value\n\t\t\t\tcase \"TCPRenoRecovery\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRenoRecovery = value\n\t\t\t\tcase \"TCPSackRecovery\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSackRecovery = value\n\t\t\t\tcase \"TCPSACKReneging\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSACKReneging = value\n\t\t\t\tcase \"TCPSACKReorder\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSACKReorder = value\n\t\t\t\tcase \"TCPRenoReorder\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRenoReorder = value\n\t\t\t\tcase \"TCPTSReorder\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPTSReorder = value\n\t\t\t\tcase \"TCPFullUndo\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFullUndo = value\n\t\t\t\tcase \"TCPPartialUndo\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPPartialUndo = value\n\t\t\t\tcase \"TCPDSACKUndo\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDSACKUndo = value\n\t\t\t\tcase \"TCPLossUndo\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPLossUndo = value\n\t\t\t\tcase \"TCPLostRetransmit\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPLostRetransmit = value\n\t\t\t\tcase \"TCPRenoFailures\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRenoFailures = value\n\t\t\t\tcase \"TCPSackFailures\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSackFailures = value\n\t\t\t\tcase \"TCPLossFailures\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPLossFailures = value\n\t\t\t\tcase \"TCPFastRetrans\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastRetrans = value\n\t\t\t\tcase \"TCPSlowStartRetrans\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSlowStartRetrans = value\n\t\t\t\tcase \"TCPTimeouts\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPTimeouts = value\n\t\t\t\tcase \"TCPLossProbes\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPLossProbes = value\n\t\t\t\tcase \"TCPLossProbeRecovery\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPLossProbeRecovery = value\n\t\t\t\tcase \"TCPRenoRecoveryFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRenoRecoveryFail = value\n\t\t\t\tcase \"TCPSackRecoveryFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSackRecoveryFail = value\n\t\t\t\tcase \"TCPRcvCollapsed\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRcvCollapsed = value\n\t\t\t\tcase \"TCPDSACKOldSent\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDSACKOldSent = value\n\t\t\t\tcase \"TCPDSACKOfoSent\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDSACKOfoSent = value\n\t\t\t\tcase \"TCPDSACKRecv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDSACKRecv = value\n\t\t\t\tcase \"TCPDSACKOfoRecv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDSACKOfoRecv = value\n\t\t\t\tcase \"TCPAbortOnData\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPAbortOnData = value\n\t\t\t\tcase \"TCPAbortOnClose\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPAbortOnClose = value\n\t\t\t\tcase \"TCPDeferAcceptDrop\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPDeferAcceptDrop = value\n\t\t\t\tcase \"IPReversePathFilter\":\n\t\t\t\t\tprocNetstat.TcpExt.IPReversePathFilter = value\n\t\t\t\tcase \"TCPTimeWaitOverflow\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPTimeWaitOverflow = value\n\t\t\t\tcase \"TCPReqQFullDoCookies\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPReqQFullDoCookies = value\n\t\t\t\tcase \"TCPReqQFullDrop\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPReqQFullDrop = value\n\t\t\t\tcase \"TCPRetransFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRetransFail = value\n\t\t\t\tcase \"TCPRcvCoalesce\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPRcvCoalesce = value\n\t\t\t\tcase \"TCPOFOQueue\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPOFOQueue = value\n\t\t\t\tcase \"TCPOFODrop\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPOFODrop = value\n\t\t\t\tcase \"TCPOFOMerge\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPOFOMerge = value\n\t\t\t\tcase \"TCPChallengeACK\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPChallengeACK = value\n\t\t\t\tcase \"TCPSYNChallenge\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSYNChallenge = value\n\t\t\t\tcase \"TCPFastOpenActive\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenActive = value\n\t\t\t\tcase \"TCPFastOpenActiveFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenActiveFail = value\n\t\t\t\tcase \"TCPFastOpenPassive\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenPassive = value\n\t\t\t\tcase \"TCPFastOpenPassiveFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenPassiveFail = value\n\t\t\t\tcase \"TCPFastOpenListenOverflow\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenListenOverflow = value\n\t\t\t\tcase \"TCPFastOpenCookieReqd\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenCookieReqd = value\n\t\t\t\tcase \"TCPFastOpenBlackhole\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFastOpenBlackhole = value\n\t\t\t\tcase \"TCPSpuriousRtxHostQueues\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSpuriousRtxHostQueues = value\n\t\t\t\tcase \"BusyPollRxPackets\":\n\t\t\t\t\tprocNetstat.TcpExt.BusyPollRxPackets = value\n\t\t\t\tcase \"TCPAutoCorking\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPAutoCorking = value\n\t\t\t\tcase \"TCPFromZeroWindowAdv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPFromZeroWindowAdv = value\n\t\t\t\tcase \"TCPToZeroWindowAdv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPToZeroWindowAdv = value\n\t\t\t\tcase \"TCPWantZeroWindowAdv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPWantZeroWindowAdv = value\n\t\t\t\tcase \"TCPSynRetrans\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPSynRetrans = value\n\t\t\t\tcase \"TCPOrigDataSent\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPOrigDataSent = value\n\t\t\t\tcase \"TCPHystartTrainDetect\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHystartTrainDetect = value\n\t\t\t\tcase \"TCPHystartTrainCwnd\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHystartTrainCwnd = value\n\t\t\t\tcase \"TCPHystartDelayDetect\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHystartDelayDetect = value\n\t\t\t\tcase \"TCPHystartDelayCwnd\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPHystartDelayCwnd = value\n\t\t\t\tcase \"TCPACKSkippedSynRecv\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedSynRecv = value\n\t\t\t\tcase \"TCPACKSkippedPAWS\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedPAWS = value\n\t\t\t\tcase \"TCPACKSkippedSeq\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedSeq = value\n\t\t\t\tcase \"TCPACKSkippedFinWait2\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedFinWait2 = value\n\t\t\t\tcase \"TCPACKSkippedTimeWait\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedTimeWait = value\n\t\t\t\tcase \"TCPACKSkippedChallenge\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPACKSkippedChallenge = value\n\t\t\t\tcase \"TCPWinProbe\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPWinProbe = value\n\t\t\t\tcase \"TCPKeepAlive\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPKeepAlive = value\n\t\t\t\tcase \"TCPMTUPFail\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPMTUPFail = value\n\t\t\t\tcase \"TCPMTUPSuccess\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPMTUPSuccess = value\n\t\t\t\tcase \"TCPWqueueTooBig\":\n\t\t\t\t\tprocNetstat.TcpExt.TCPWqueueTooBig = value\n\t\t\t\t}\n\t\t\tcase \"IpExt\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InNoRoutes\":\n\t\t\t\t\tprocNetstat.IpExt.InNoRoutes = value\n\t\t\t\tcase \"InTruncatedPkts\":\n\t\t\t\t\tprocNetstat.IpExt.InTruncatedPkts = value\n\t\t\t\tcase \"InMcastPkts\":\n\t\t\t\t\tprocNetstat.IpExt.InMcastPkts = value\n\t\t\t\tcase \"OutMcastPkts\":\n\t\t\t\t\tprocNetstat.IpExt.OutMcastPkts = value\n\t\t\t\tcase \"InBcastPkts\":\n\t\t\t\t\tprocNetstat.IpExt.InBcastPkts = value\n\t\t\t\tcase \"OutBcastPkts\":\n\t\t\t\t\tprocNetstat.IpExt.OutBcastPkts = value\n\t\t\t\tcase \"InOctets\":\n\t\t\t\t\tprocNetstat.IpExt.InOctets = value\n\t\t\t\tcase \"OutOctets\":\n\t\t\t\t\tprocNetstat.IpExt.OutOctets = value\n\t\t\t\tcase \"InMcastOctets\":\n\t\t\t\t\tprocNetstat.IpExt.InMcastOctets = value\n\t\t\t\tcase \"OutMcastOctets\":\n\t\t\t\t\tprocNetstat.IpExt.OutMcastOctets = value\n\t\t\t\tcase \"InBcastOctets\":\n\t\t\t\t\tprocNetstat.IpExt.InBcastOctets = value\n\t\t\t\tcase \"OutBcastOctets\":\n\t\t\t\t\tprocNetstat.IpExt.OutBcastOctets = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocNetstat.IpExt.InCsumErrors = value\n\t\t\t\tcase \"InNoECTPkts\":\n\t\t\t\t\tprocNetstat.IpExt.InNoECTPkts = value\n\t\t\t\tcase \"InECT1Pkts\":\n\t\t\t\t\tprocNetstat.IpExt.InECT1Pkts = value\n\t\t\t\tcase \"InECT0Pkts\":\n\t\t\t\t\tprocNetstat.IpExt.InECT0Pkts = value\n\t\t\t\tcase \"InCEPkts\":\n\t\t\t\t\tprocNetstat.IpExt.InCEPkts = value\n\t\t\t\tcase \"ReasmOverlaps\":\n\t\t\t\t\tprocNetstat.IpExt.ReasmOverlaps = value\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn procNetstat, scanner.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_ns.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// Namespace represents a single namespace of a process.\ntype Namespace struct {\n\tType string // Namespace type.\n\tInode uint32 // Inode number of the namespace. If two processes are in the same namespace their inodes will match.\n}\n\n// Namespaces contains all of the namespaces that the process is contained in.\ntype Namespaces map[string]Namespace\n\n// Namespaces reads from /proc//ns/* to get the namespaces of which the\n// process is a member.\nfunc (p Proc) Namespaces() (Namespaces, error) {\n\td, err := os.Open(p.path(\"ns\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer d.Close()\n\n\tnames, err := d.Readdirnames(-1)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to read contents of ns dir: %w\", err)\n\t}\n\n\tns := make(Namespaces, len(names))\n\tfor _, name := range names {\n\t\ttarget, err := os.Readlink(p.path(\"ns\", name))\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tfields := strings.SplitN(target, \":\", 2)\n\t\tif len(fields) != 2 {\n\t\t\treturn nil, fmt.Errorf(\"failed to parse namespace type and inode from %q\", target)\n\t\t}\n\n\t\ttyp := fields[0]\n\t\tinode, err := strconv.ParseUint(strings.Trim(fields[1], \"[]\"), 10, 32)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"failed to parse inode from %q: %w\", fields[1], err)\n\t\t}\n\n\t\tns[name] = Namespace{typ, uint32(inode)}\n\t}\n\n\treturn ns, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_psi.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\n// The PSI / pressure interface is described at\n// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/accounting/psi.txt\n// Each resource (cpu, io, memory, ...) is exposed as a single file.\n// Each file may contain up to two lines, one for \"some\" pressure and one for \"full\" pressure.\n// Each line contains several averages (over n seconds) and a total in µs.\n//\n// Example io pressure file:\n// > some avg10=0.06 avg60=0.21 avg300=0.99 total=8537362\n// > full avg10=0.00 avg60=0.13 avg300=0.96 total=8183134\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\nconst lineFormat = \"avg10=%f avg60=%f avg300=%f total=%d\"\n\n// PSILine is a single line of values as returned by `/proc/pressure/*`.\n//\n// The Avg entries are averages over n seconds, as a percentage.\n// The Total line is in microseconds.\ntype PSILine struct {\n\tAvg10 float64\n\tAvg60 float64\n\tAvg300 float64\n\tTotal uint64\n}\n\n// PSIStats represent pressure stall information from /proc/pressure/*\n//\n// \"Some\" indicates the share of time in which at least some tasks are stalled.\n// \"Full\" indicates the share of time in which all non-idle tasks are stalled simultaneously.\ntype PSIStats struct {\n\tSome *PSILine\n\tFull *PSILine\n}\n\n// PSIStatsForResource reads pressure stall information for the specified\n// resource from /proc/pressure/. At time of writing this can be\n// either \"cpu\", \"memory\" or \"io\".\nfunc (fs FS) PSIStatsForResource(resource string) (PSIStats, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(fmt.Sprintf(\"%s/%s\", \"pressure\", resource)))\n\tif err != nil {\n\t\treturn PSIStats{}, fmt.Errorf(\"psi_stats: unavailable for %q: %w\", resource, err)\n\t}\n\n\treturn parsePSIStats(resource, bytes.NewReader(data))\n}\n\n// parsePSIStats parses the specified file for pressure stall information.\nfunc parsePSIStats(resource string, r io.Reader) (PSIStats, error) {\n\tpsiStats := PSIStats{}\n\n\tscanner := bufio.NewScanner(r)\n\tfor scanner.Scan() {\n\t\tl := scanner.Text()\n\t\tprefix := strings.Split(l, \" \")[0]\n\t\tswitch prefix {\n\t\tcase \"some\":\n\t\t\tpsi := PSILine{}\n\t\t\t_, err := fmt.Sscanf(l, fmt.Sprintf(\"some %s\", lineFormat), &psi.Avg10, &psi.Avg60, &psi.Avg300, &psi.Total)\n\t\t\tif err != nil {\n\t\t\t\treturn PSIStats{}, err\n\t\t\t}\n\t\t\tpsiStats.Some = &psi\n\t\tcase \"full\":\n\t\t\tpsi := PSILine{}\n\t\t\t_, err := fmt.Sscanf(l, fmt.Sprintf(\"full %s\", lineFormat), &psi.Avg10, &psi.Avg60, &psi.Avg300, &psi.Total)\n\t\t\tif err != nil {\n\t\t\t\treturn PSIStats{}, err\n\t\t\t}\n\t\t\tpsiStats.Full = &psi\n\t\tdefault:\n\t\t\t// If we encounter a line with an unknown prefix, ignore it and move on\n\t\t\t// Should new measurement types be added in the future we'll simply ignore them instead\n\t\t\t// of erroring on retrieval\n\t\t\tcontinue\n\t\t}\n\t}\n\n\treturn psiStats, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_smaps.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows\n// +build !windows\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\nvar (\n\t// match the header line before each mapped zone in `/proc/pid/smaps`.\n\tprocSMapsHeaderLine = regexp.MustCompile(`^[a-f0-9].*$`)\n)\n\ntype ProcSMapsRollup struct {\n\t// Amount of the mapping that is currently resident in RAM.\n\tRss uint64\n\t// Process's proportional share of this mapping.\n\tPss uint64\n\t// Size in bytes of clean shared pages.\n\tSharedClean uint64\n\t// Size in bytes of dirty shared pages.\n\tSharedDirty uint64\n\t// Size in bytes of clean private pages.\n\tPrivateClean uint64\n\t// Size in bytes of dirty private pages.\n\tPrivateDirty uint64\n\t// Amount of memory currently marked as referenced or accessed.\n\tReferenced uint64\n\t// Amount of memory that does not belong to any file.\n\tAnonymous uint64\n\t// Amount would-be-anonymous memory currently on swap.\n\tSwap uint64\n\t// Process's proportional memory on swap.\n\tSwapPss uint64\n}\n\n// ProcSMapsRollup reads from /proc/[pid]/smaps_rollup to get summed memory information of the\n// process.\n//\n// If smaps_rollup does not exists (require kernel >= 4.15), the content of /proc/pid/smaps will\n// we read and summed.\nfunc (p Proc) ProcSMapsRollup() (ProcSMapsRollup, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"smaps_rollup\"))\n\tif err != nil && os.IsNotExist(err) {\n\t\treturn p.procSMapsRollupManual()\n\t}\n\tif err != nil {\n\t\treturn ProcSMapsRollup{}, err\n\t}\n\n\tlines := strings.Split(string(data), \"\\n\")\n\tsmaps := ProcSMapsRollup{}\n\n\t// skip first line which don't contains information we need\n\tlines = lines[1:]\n\tfor _, line := range lines {\n\t\tif line == \"\" {\n\t\t\tcontinue\n\t\t}\n\n\t\tif err := smaps.parseLine(line); err != nil {\n\t\t\treturn ProcSMapsRollup{}, err\n\t\t}\n\t}\n\n\treturn smaps, nil\n}\n\n// Read /proc/pid/smaps and do the roll-up in Go code.\nfunc (p Proc) procSMapsRollupManual() (ProcSMapsRollup, error) {\n\tfile, err := os.Open(p.path(\"smaps\"))\n\tif err != nil {\n\t\treturn ProcSMapsRollup{}, err\n\t}\n\tdefer file.Close()\n\n\tsmaps := ProcSMapsRollup{}\n\tscan := bufio.NewScanner(file)\n\n\tfor scan.Scan() {\n\t\tline := scan.Text()\n\n\t\tif procSMapsHeaderLine.MatchString(line) {\n\t\t\tcontinue\n\t\t}\n\n\t\tif err := smaps.parseLine(line); err != nil {\n\t\t\treturn ProcSMapsRollup{}, err\n\t\t}\n\t}\n\n\treturn smaps, nil\n}\n\nfunc (s *ProcSMapsRollup) parseLine(line string) error {\n\tkv := strings.SplitN(line, \":\", 2)\n\tif len(kv) != 2 {\n\t\tfmt.Println(line)\n\t\treturn errors.New(\"invalid net/dev line, missing colon\")\n\t}\n\n\tk := kv[0]\n\tif k == \"VmFlags\" {\n\t\treturn nil\n\t}\n\n\tv := strings.TrimSpace(kv[1])\n\tv = strings.TrimRight(v, \" kB\")\n\n\tvKBytes, err := strconv.ParseUint(v, 10, 64)\n\tif err != nil {\n\t\treturn err\n\t}\n\tvBytes := vKBytes * 1024\n\n\ts.addValue(k, v, vKBytes, vBytes)\n\n\treturn nil\n}\n\nfunc (s *ProcSMapsRollup) addValue(k string, vString string, vUint uint64, vUintBytes uint64) {\n\tswitch k {\n\tcase \"Rss\":\n\t\ts.Rss += vUintBytes\n\tcase \"Pss\":\n\t\ts.Pss += vUintBytes\n\tcase \"Shared_Clean\":\n\t\ts.SharedClean += vUintBytes\n\tcase \"Shared_Dirty\":\n\t\ts.SharedDirty += vUintBytes\n\tcase \"Private_Clean\":\n\t\ts.PrivateClean += vUintBytes\n\tcase \"Private_Dirty\":\n\t\ts.PrivateDirty += vUintBytes\n\tcase \"Referenced\":\n\t\ts.Referenced += vUintBytes\n\tcase \"Anonymous\":\n\t\ts.Anonymous += vUintBytes\n\tcase \"Swap\":\n\t\ts.Swap += vUintBytes\n\tcase \"SwapPss\":\n\t\ts.SwapPss += vUintBytes\n\t}\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_snmp.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// ProcSnmp models the content of /proc//net/snmp.\ntype ProcSnmp struct {\n\t// The process ID.\n\tPID int\n\tIp\n\tIcmp\n\tIcmpMsg\n\tTcp\n\tUdp\n\tUdpLite\n}\n\ntype Ip struct { // nolint:revive\n\tForwarding float64\n\tDefaultTTL float64\n\tInReceives float64\n\tInHdrErrors float64\n\tInAddrErrors float64\n\tForwDatagrams float64\n\tInUnknownProtos float64\n\tInDiscards float64\n\tInDelivers float64\n\tOutRequests float64\n\tOutDiscards float64\n\tOutNoRoutes float64\n\tReasmTimeout float64\n\tReasmReqds float64\n\tReasmOKs float64\n\tReasmFails float64\n\tFragOKs float64\n\tFragFails float64\n\tFragCreates float64\n}\n\ntype Icmp struct {\n\tInMsgs float64\n\tInErrors float64\n\tInCsumErrors float64\n\tInDestUnreachs float64\n\tInTimeExcds float64\n\tInParmProbs float64\n\tInSrcQuenchs float64\n\tInRedirects float64\n\tInEchos float64\n\tInEchoReps float64\n\tInTimestamps float64\n\tInTimestampReps float64\n\tInAddrMasks float64\n\tInAddrMaskReps float64\n\tOutMsgs float64\n\tOutErrors float64\n\tOutDestUnreachs float64\n\tOutTimeExcds float64\n\tOutParmProbs float64\n\tOutSrcQuenchs float64\n\tOutRedirects float64\n\tOutEchos float64\n\tOutEchoReps float64\n\tOutTimestamps float64\n\tOutTimestampReps float64\n\tOutAddrMasks float64\n\tOutAddrMaskReps float64\n}\n\ntype IcmpMsg struct {\n\tInType3 float64\n\tOutType3 float64\n}\n\ntype Tcp struct { // nolint:revive\n\tRtoAlgorithm float64\n\tRtoMin float64\n\tRtoMax float64\n\tMaxConn float64\n\tActiveOpens float64\n\tPassiveOpens float64\n\tAttemptFails float64\n\tEstabResets float64\n\tCurrEstab float64\n\tInSegs float64\n\tOutSegs float64\n\tRetransSegs float64\n\tInErrs float64\n\tOutRsts float64\n\tInCsumErrors float64\n}\n\ntype Udp struct { // nolint:revive\n\tInDatagrams float64\n\tNoPorts float64\n\tInErrors float64\n\tOutDatagrams float64\n\tRcvbufErrors float64\n\tSndbufErrors float64\n\tInCsumErrors float64\n\tIgnoredMulti float64\n}\n\ntype UdpLite struct { // nolint:revive\n\tInDatagrams float64\n\tNoPorts float64\n\tInErrors float64\n\tOutDatagrams float64\n\tRcvbufErrors float64\n\tSndbufErrors float64\n\tInCsumErrors float64\n\tIgnoredMulti float64\n}\n\nfunc (p Proc) Snmp() (ProcSnmp, error) {\n\tfilename := p.path(\"net/snmp\")\n\tdata, err := util.ReadFileNoStat(filename)\n\tif err != nil {\n\t\treturn ProcSnmp{PID: p.PID}, err\n\t}\n\tprocSnmp, err := parseSnmp(bytes.NewReader(data), filename)\n\tprocSnmp.PID = p.PID\n\treturn procSnmp, err\n}\n\n// parseSnmp parses the metrics from proc//net/snmp file\n// and returns a map contains those metrics (e.g. {\"Ip\": {\"Forwarding\": 2}}).\nfunc parseSnmp(r io.Reader, fileName string) (ProcSnmp, error) {\n\tvar (\n\t\tscanner = bufio.NewScanner(r)\n\t\tprocSnmp = ProcSnmp{}\n\t)\n\n\tfor scanner.Scan() {\n\t\tnameParts := strings.Split(scanner.Text(), \" \")\n\t\tscanner.Scan()\n\t\tvalueParts := strings.Split(scanner.Text(), \" \")\n\t\t// Remove trailing :.\n\t\tprotocol := strings.TrimSuffix(nameParts[0], \":\")\n\t\tif len(nameParts) != len(valueParts) {\n\t\t\treturn procSnmp, fmt.Errorf(\"mismatch field count mismatch in %s: %s\",\n\t\t\t\tfileName, protocol)\n\t\t}\n\t\tfor i := 1; i < len(nameParts); i++ {\n\t\t\tvalue, err := strconv.ParseFloat(valueParts[i], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn procSnmp, err\n\t\t\t}\n\t\t\tkey := nameParts[i]\n\n\t\t\tswitch protocol {\n\t\t\tcase \"Ip\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"Forwarding\":\n\t\t\t\t\tprocSnmp.Ip.Forwarding = value\n\t\t\t\tcase \"DefaultTTL\":\n\t\t\t\t\tprocSnmp.Ip.DefaultTTL = value\n\t\t\t\tcase \"InReceives\":\n\t\t\t\t\tprocSnmp.Ip.InReceives = value\n\t\t\t\tcase \"InHdrErrors\":\n\t\t\t\t\tprocSnmp.Ip.InHdrErrors = value\n\t\t\t\tcase \"InAddrErrors\":\n\t\t\t\t\tprocSnmp.Ip.InAddrErrors = value\n\t\t\t\tcase \"ForwDatagrams\":\n\t\t\t\t\tprocSnmp.Ip.ForwDatagrams = value\n\t\t\t\tcase \"InUnknownProtos\":\n\t\t\t\t\tprocSnmp.Ip.InUnknownProtos = value\n\t\t\t\tcase \"InDiscards\":\n\t\t\t\t\tprocSnmp.Ip.InDiscards = value\n\t\t\t\tcase \"InDelivers\":\n\t\t\t\t\tprocSnmp.Ip.InDelivers = value\n\t\t\t\tcase \"OutRequests\":\n\t\t\t\t\tprocSnmp.Ip.OutRequests = value\n\t\t\t\tcase \"OutDiscards\":\n\t\t\t\t\tprocSnmp.Ip.OutDiscards = value\n\t\t\t\tcase \"OutNoRoutes\":\n\t\t\t\t\tprocSnmp.Ip.OutNoRoutes = value\n\t\t\t\tcase \"ReasmTimeout\":\n\t\t\t\t\tprocSnmp.Ip.ReasmTimeout = value\n\t\t\t\tcase \"ReasmReqds\":\n\t\t\t\t\tprocSnmp.Ip.ReasmReqds = value\n\t\t\t\tcase \"ReasmOKs\":\n\t\t\t\t\tprocSnmp.Ip.ReasmOKs = value\n\t\t\t\tcase \"ReasmFails\":\n\t\t\t\t\tprocSnmp.Ip.ReasmFails = value\n\t\t\t\tcase \"FragOKs\":\n\t\t\t\t\tprocSnmp.Ip.FragOKs = value\n\t\t\t\tcase \"FragFails\":\n\t\t\t\t\tprocSnmp.Ip.FragFails = value\n\t\t\t\tcase \"FragCreates\":\n\t\t\t\t\tprocSnmp.Ip.FragCreates = value\n\t\t\t\t}\n\t\t\tcase \"Icmp\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InMsgs\":\n\t\t\t\t\tprocSnmp.Icmp.InMsgs = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp.Icmp.InErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp.Icmp.InCsumErrors = value\n\t\t\t\tcase \"InDestUnreachs\":\n\t\t\t\t\tprocSnmp.Icmp.InDestUnreachs = value\n\t\t\t\tcase \"InTimeExcds\":\n\t\t\t\t\tprocSnmp.Icmp.InTimeExcds = value\n\t\t\t\tcase \"InParmProbs\":\n\t\t\t\t\tprocSnmp.Icmp.InParmProbs = value\n\t\t\t\tcase \"InSrcQuenchs\":\n\t\t\t\t\tprocSnmp.Icmp.InSrcQuenchs = value\n\t\t\t\tcase \"InRedirects\":\n\t\t\t\t\tprocSnmp.Icmp.InRedirects = value\n\t\t\t\tcase \"InEchos\":\n\t\t\t\t\tprocSnmp.Icmp.InEchos = value\n\t\t\t\tcase \"InEchoReps\":\n\t\t\t\t\tprocSnmp.Icmp.InEchoReps = value\n\t\t\t\tcase \"InTimestamps\":\n\t\t\t\t\tprocSnmp.Icmp.InTimestamps = value\n\t\t\t\tcase \"InTimestampReps\":\n\t\t\t\t\tprocSnmp.Icmp.InTimestampReps = value\n\t\t\t\tcase \"InAddrMasks\":\n\t\t\t\t\tprocSnmp.Icmp.InAddrMasks = value\n\t\t\t\tcase \"InAddrMaskReps\":\n\t\t\t\t\tprocSnmp.Icmp.InAddrMaskReps = value\n\t\t\t\tcase \"OutMsgs\":\n\t\t\t\t\tprocSnmp.Icmp.OutMsgs = value\n\t\t\t\tcase \"OutErrors\":\n\t\t\t\t\tprocSnmp.Icmp.OutErrors = value\n\t\t\t\tcase \"OutDestUnreachs\":\n\t\t\t\t\tprocSnmp.Icmp.OutDestUnreachs = value\n\t\t\t\tcase \"OutTimeExcds\":\n\t\t\t\t\tprocSnmp.Icmp.OutTimeExcds = value\n\t\t\t\tcase \"OutParmProbs\":\n\t\t\t\t\tprocSnmp.Icmp.OutParmProbs = value\n\t\t\t\tcase \"OutSrcQuenchs\":\n\t\t\t\t\tprocSnmp.Icmp.OutSrcQuenchs = value\n\t\t\t\tcase \"OutRedirects\":\n\t\t\t\t\tprocSnmp.Icmp.OutRedirects = value\n\t\t\t\tcase \"OutEchos\":\n\t\t\t\t\tprocSnmp.Icmp.OutEchos = value\n\t\t\t\tcase \"OutEchoReps\":\n\t\t\t\t\tprocSnmp.Icmp.OutEchoReps = value\n\t\t\t\tcase \"OutTimestamps\":\n\t\t\t\t\tprocSnmp.Icmp.OutTimestamps = value\n\t\t\t\tcase \"OutTimestampReps\":\n\t\t\t\t\tprocSnmp.Icmp.OutTimestampReps = value\n\t\t\t\tcase \"OutAddrMasks\":\n\t\t\t\t\tprocSnmp.Icmp.OutAddrMasks = value\n\t\t\t\tcase \"OutAddrMaskReps\":\n\t\t\t\t\tprocSnmp.Icmp.OutAddrMaskReps = value\n\t\t\t\t}\n\t\t\tcase \"IcmpMsg\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InType3\":\n\t\t\t\t\tprocSnmp.IcmpMsg.InType3 = value\n\t\t\t\tcase \"OutType3\":\n\t\t\t\t\tprocSnmp.IcmpMsg.OutType3 = value\n\t\t\t\t}\n\t\t\tcase \"Tcp\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"RtoAlgorithm\":\n\t\t\t\t\tprocSnmp.Tcp.RtoAlgorithm = value\n\t\t\t\tcase \"RtoMin\":\n\t\t\t\t\tprocSnmp.Tcp.RtoMin = value\n\t\t\t\tcase \"RtoMax\":\n\t\t\t\t\tprocSnmp.Tcp.RtoMax = value\n\t\t\t\tcase \"MaxConn\":\n\t\t\t\t\tprocSnmp.Tcp.MaxConn = value\n\t\t\t\tcase \"ActiveOpens\":\n\t\t\t\t\tprocSnmp.Tcp.ActiveOpens = value\n\t\t\t\tcase \"PassiveOpens\":\n\t\t\t\t\tprocSnmp.Tcp.PassiveOpens = value\n\t\t\t\tcase \"AttemptFails\":\n\t\t\t\t\tprocSnmp.Tcp.AttemptFails = value\n\t\t\t\tcase \"EstabResets\":\n\t\t\t\t\tprocSnmp.Tcp.EstabResets = value\n\t\t\t\tcase \"CurrEstab\":\n\t\t\t\t\tprocSnmp.Tcp.CurrEstab = value\n\t\t\t\tcase \"InSegs\":\n\t\t\t\t\tprocSnmp.Tcp.InSegs = value\n\t\t\t\tcase \"OutSegs\":\n\t\t\t\t\tprocSnmp.Tcp.OutSegs = value\n\t\t\t\tcase \"RetransSegs\":\n\t\t\t\t\tprocSnmp.Tcp.RetransSegs = value\n\t\t\t\tcase \"InErrs\":\n\t\t\t\t\tprocSnmp.Tcp.InErrs = value\n\t\t\t\tcase \"OutRsts\":\n\t\t\t\t\tprocSnmp.Tcp.OutRsts = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp.Tcp.InCsumErrors = value\n\t\t\t\t}\n\t\t\tcase \"Udp\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InDatagrams\":\n\t\t\t\t\tprocSnmp.Udp.InDatagrams = value\n\t\t\t\tcase \"NoPorts\":\n\t\t\t\t\tprocSnmp.Udp.NoPorts = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp.Udp.InErrors = value\n\t\t\t\tcase \"OutDatagrams\":\n\t\t\t\t\tprocSnmp.Udp.OutDatagrams = value\n\t\t\t\tcase \"RcvbufErrors\":\n\t\t\t\t\tprocSnmp.Udp.RcvbufErrors = value\n\t\t\t\tcase \"SndbufErrors\":\n\t\t\t\t\tprocSnmp.Udp.SndbufErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp.Udp.InCsumErrors = value\n\t\t\t\tcase \"IgnoredMulti\":\n\t\t\t\t\tprocSnmp.Udp.IgnoredMulti = value\n\t\t\t\t}\n\t\t\tcase \"UdpLite\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InDatagrams\":\n\t\t\t\t\tprocSnmp.UdpLite.InDatagrams = value\n\t\t\t\tcase \"NoPorts\":\n\t\t\t\t\tprocSnmp.UdpLite.NoPorts = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp.UdpLite.InErrors = value\n\t\t\t\tcase \"OutDatagrams\":\n\t\t\t\t\tprocSnmp.UdpLite.OutDatagrams = value\n\t\t\t\tcase \"RcvbufErrors\":\n\t\t\t\t\tprocSnmp.UdpLite.RcvbufErrors = value\n\t\t\t\tcase \"SndbufErrors\":\n\t\t\t\t\tprocSnmp.UdpLite.SndbufErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp.UdpLite.InCsumErrors = value\n\t\t\t\tcase \"IgnoredMulti\":\n\t\t\t\t\tprocSnmp.UdpLite.IgnoredMulti = value\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn procSnmp, scanner.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_snmp6.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"errors\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// ProcSnmp6 models the content of /proc//net/snmp6.\ntype ProcSnmp6 struct {\n\t// The process ID.\n\tPID int\n\tIp6\n\tIcmp6\n\tUdp6\n\tUdpLite6\n}\n\ntype Ip6 struct { // nolint:revive\n\tInReceives float64\n\tInHdrErrors float64\n\tInTooBigErrors float64\n\tInNoRoutes float64\n\tInAddrErrors float64\n\tInUnknownProtos float64\n\tInTruncatedPkts float64\n\tInDiscards float64\n\tInDelivers float64\n\tOutForwDatagrams float64\n\tOutRequests float64\n\tOutDiscards float64\n\tOutNoRoutes float64\n\tReasmTimeout float64\n\tReasmReqds float64\n\tReasmOKs float64\n\tReasmFails float64\n\tFragOKs float64\n\tFragFails float64\n\tFragCreates float64\n\tInMcastPkts float64\n\tOutMcastPkts float64\n\tInOctets float64\n\tOutOctets float64\n\tInMcastOctets float64\n\tOutMcastOctets float64\n\tInBcastOctets float64\n\tOutBcastOctets float64\n\tInNoECTPkts float64\n\tInECT1Pkts float64\n\tInECT0Pkts float64\n\tInCEPkts float64\n}\n\ntype Icmp6 struct {\n\tInMsgs float64\n\tInErrors float64\n\tOutMsgs float64\n\tOutErrors float64\n\tInCsumErrors float64\n\tInDestUnreachs float64\n\tInPktTooBigs float64\n\tInTimeExcds float64\n\tInParmProblems float64\n\tInEchos float64\n\tInEchoReplies float64\n\tInGroupMembQueries float64\n\tInGroupMembResponses float64\n\tInGroupMembReductions float64\n\tInRouterSolicits float64\n\tInRouterAdvertisements float64\n\tInNeighborSolicits float64\n\tInNeighborAdvertisements float64\n\tInRedirects float64\n\tInMLDv2Reports float64\n\tOutDestUnreachs float64\n\tOutPktTooBigs float64\n\tOutTimeExcds float64\n\tOutParmProblems float64\n\tOutEchos float64\n\tOutEchoReplies float64\n\tOutGroupMembQueries float64\n\tOutGroupMembResponses float64\n\tOutGroupMembReductions float64\n\tOutRouterSolicits float64\n\tOutRouterAdvertisements float64\n\tOutNeighborSolicits float64\n\tOutNeighborAdvertisements float64\n\tOutRedirects float64\n\tOutMLDv2Reports float64\n\tInType1 float64\n\tInType134 float64\n\tInType135 float64\n\tInType136 float64\n\tInType143 float64\n\tOutType133 float64\n\tOutType135 float64\n\tOutType136 float64\n\tOutType143 float64\n}\n\ntype Udp6 struct { // nolint:revive\n\tInDatagrams float64\n\tNoPorts float64\n\tInErrors float64\n\tOutDatagrams float64\n\tRcvbufErrors float64\n\tSndbufErrors float64\n\tInCsumErrors float64\n\tIgnoredMulti float64\n}\n\ntype UdpLite6 struct { // nolint:revive\n\tInDatagrams float64\n\tNoPorts float64\n\tInErrors float64\n\tOutDatagrams float64\n\tRcvbufErrors float64\n\tSndbufErrors float64\n\tInCsumErrors float64\n}\n\nfunc (p Proc) Snmp6() (ProcSnmp6, error) {\n\tfilename := p.path(\"net/snmp6\")\n\tdata, err := util.ReadFileNoStat(filename)\n\tif err != nil {\n\t\t// On systems with IPv6 disabled, this file won't exist.\n\t\t// Do nothing.\n\t\tif errors.Is(err, os.ErrNotExist) {\n\t\t\treturn ProcSnmp6{PID: p.PID}, nil\n\t\t}\n\n\t\treturn ProcSnmp6{PID: p.PID}, err\n\t}\n\n\tprocSnmp6, err := parseSNMP6Stats(bytes.NewReader(data))\n\tprocSnmp6.PID = p.PID\n\treturn procSnmp6, err\n}\n\n// parseSnmp6 parses the metrics from proc//net/snmp6 file\n// and returns a map contains those metrics.\nfunc parseSNMP6Stats(r io.Reader) (ProcSnmp6, error) {\n\tvar (\n\t\tscanner = bufio.NewScanner(r)\n\t\tprocSnmp6 = ProcSnmp6{}\n\t)\n\n\tfor scanner.Scan() {\n\t\tstat := strings.Fields(scanner.Text())\n\t\tif len(stat) < 2 {\n\t\t\tcontinue\n\t\t}\n\t\t// Expect to have \"6\" in metric name, skip line otherwise\n\t\tif sixIndex := strings.Index(stat[0], \"6\"); sixIndex != -1 {\n\t\t\tprotocol := stat[0][:sixIndex+1]\n\t\t\tkey := stat[0][sixIndex+1:]\n\t\t\tvalue, err := strconv.ParseFloat(stat[1], 64)\n\t\t\tif err != nil {\n\t\t\t\treturn procSnmp6, err\n\t\t\t}\n\n\t\t\tswitch protocol {\n\t\t\tcase \"Ip6\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InReceives\":\n\t\t\t\t\tprocSnmp6.Ip6.InReceives = value\n\t\t\t\tcase \"InHdrErrors\":\n\t\t\t\t\tprocSnmp6.Ip6.InHdrErrors = value\n\t\t\t\tcase \"InTooBigErrors\":\n\t\t\t\t\tprocSnmp6.Ip6.InTooBigErrors = value\n\t\t\t\tcase \"InNoRoutes\":\n\t\t\t\t\tprocSnmp6.Ip6.InNoRoutes = value\n\t\t\t\tcase \"InAddrErrors\":\n\t\t\t\t\tprocSnmp6.Ip6.InAddrErrors = value\n\t\t\t\tcase \"InUnknownProtos\":\n\t\t\t\t\tprocSnmp6.Ip6.InUnknownProtos = value\n\t\t\t\tcase \"InTruncatedPkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InTruncatedPkts = value\n\t\t\t\tcase \"InDiscards\":\n\t\t\t\t\tprocSnmp6.Ip6.InDiscards = value\n\t\t\t\tcase \"InDelivers\":\n\t\t\t\t\tprocSnmp6.Ip6.InDelivers = value\n\t\t\t\tcase \"OutForwDatagrams\":\n\t\t\t\t\tprocSnmp6.Ip6.OutForwDatagrams = value\n\t\t\t\tcase \"OutRequests\":\n\t\t\t\t\tprocSnmp6.Ip6.OutRequests = value\n\t\t\t\tcase \"OutDiscards\":\n\t\t\t\t\tprocSnmp6.Ip6.OutDiscards = value\n\t\t\t\tcase \"OutNoRoutes\":\n\t\t\t\t\tprocSnmp6.Ip6.OutNoRoutes = value\n\t\t\t\tcase \"ReasmTimeout\":\n\t\t\t\t\tprocSnmp6.Ip6.ReasmTimeout = value\n\t\t\t\tcase \"ReasmReqds\":\n\t\t\t\t\tprocSnmp6.Ip6.ReasmReqds = value\n\t\t\t\tcase \"ReasmOKs\":\n\t\t\t\t\tprocSnmp6.Ip6.ReasmOKs = value\n\t\t\t\tcase \"ReasmFails\":\n\t\t\t\t\tprocSnmp6.Ip6.ReasmFails = value\n\t\t\t\tcase \"FragOKs\":\n\t\t\t\t\tprocSnmp6.Ip6.FragOKs = value\n\t\t\t\tcase \"FragFails\":\n\t\t\t\t\tprocSnmp6.Ip6.FragFails = value\n\t\t\t\tcase \"FragCreates\":\n\t\t\t\t\tprocSnmp6.Ip6.FragCreates = value\n\t\t\t\tcase \"InMcastPkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InMcastPkts = value\n\t\t\t\tcase \"OutMcastPkts\":\n\t\t\t\t\tprocSnmp6.Ip6.OutMcastPkts = value\n\t\t\t\tcase \"InOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.InOctets = value\n\t\t\t\tcase \"OutOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.OutOctets = value\n\t\t\t\tcase \"InMcastOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.InMcastOctets = value\n\t\t\t\tcase \"OutMcastOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.OutMcastOctets = value\n\t\t\t\tcase \"InBcastOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.InBcastOctets = value\n\t\t\t\tcase \"OutBcastOctets\":\n\t\t\t\t\tprocSnmp6.Ip6.OutBcastOctets = value\n\t\t\t\tcase \"InNoECTPkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InNoECTPkts = value\n\t\t\t\tcase \"InECT1Pkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InECT1Pkts = value\n\t\t\t\tcase \"InECT0Pkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InECT0Pkts = value\n\t\t\t\tcase \"InCEPkts\":\n\t\t\t\t\tprocSnmp6.Ip6.InCEPkts = value\n\n\t\t\t\t}\n\t\t\tcase \"Icmp6\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InMsgs\":\n\t\t\t\t\tprocSnmp6.Icmp6.InMsgs = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp6.Icmp6.InErrors = value\n\t\t\t\tcase \"OutMsgs\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutMsgs = value\n\t\t\t\tcase \"OutErrors\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp6.Icmp6.InCsumErrors = value\n\t\t\t\tcase \"InDestUnreachs\":\n\t\t\t\t\tprocSnmp6.Icmp6.InDestUnreachs = value\n\t\t\t\tcase \"InPktTooBigs\":\n\t\t\t\t\tprocSnmp6.Icmp6.InPktTooBigs = value\n\t\t\t\tcase \"InTimeExcds\":\n\t\t\t\t\tprocSnmp6.Icmp6.InTimeExcds = value\n\t\t\t\tcase \"InParmProblems\":\n\t\t\t\t\tprocSnmp6.Icmp6.InParmProblems = value\n\t\t\t\tcase \"InEchos\":\n\t\t\t\t\tprocSnmp6.Icmp6.InEchos = value\n\t\t\t\tcase \"InEchoReplies\":\n\t\t\t\t\tprocSnmp6.Icmp6.InEchoReplies = value\n\t\t\t\tcase \"InGroupMembQueries\":\n\t\t\t\t\tprocSnmp6.Icmp6.InGroupMembQueries = value\n\t\t\t\tcase \"InGroupMembResponses\":\n\t\t\t\t\tprocSnmp6.Icmp6.InGroupMembResponses = value\n\t\t\t\tcase \"InGroupMembReductions\":\n\t\t\t\t\tprocSnmp6.Icmp6.InGroupMembReductions = value\n\t\t\t\tcase \"InRouterSolicits\":\n\t\t\t\t\tprocSnmp6.Icmp6.InRouterSolicits = value\n\t\t\t\tcase \"InRouterAdvertisements\":\n\t\t\t\t\tprocSnmp6.Icmp6.InRouterAdvertisements = value\n\t\t\t\tcase \"InNeighborSolicits\":\n\t\t\t\t\tprocSnmp6.Icmp6.InNeighborSolicits = value\n\t\t\t\tcase \"InNeighborAdvertisements\":\n\t\t\t\t\tprocSnmp6.Icmp6.InNeighborAdvertisements = value\n\t\t\t\tcase \"InRedirects\":\n\t\t\t\t\tprocSnmp6.Icmp6.InRedirects = value\n\t\t\t\tcase \"InMLDv2Reports\":\n\t\t\t\t\tprocSnmp6.Icmp6.InMLDv2Reports = value\n\t\t\t\tcase \"OutDestUnreachs\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutDestUnreachs = value\n\t\t\t\tcase \"OutPktTooBigs\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutPktTooBigs = value\n\t\t\t\tcase \"OutTimeExcds\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutTimeExcds = value\n\t\t\t\tcase \"OutParmProblems\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutParmProblems = value\n\t\t\t\tcase \"OutEchos\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutEchos = value\n\t\t\t\tcase \"OutEchoReplies\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutEchoReplies = value\n\t\t\t\tcase \"OutGroupMembQueries\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutGroupMembQueries = value\n\t\t\t\tcase \"OutGroupMembResponses\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutGroupMembResponses = value\n\t\t\t\tcase \"OutGroupMembReductions\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutGroupMembReductions = value\n\t\t\t\tcase \"OutRouterSolicits\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutRouterSolicits = value\n\t\t\t\tcase \"OutRouterAdvertisements\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutRouterAdvertisements = value\n\t\t\t\tcase \"OutNeighborSolicits\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutNeighborSolicits = value\n\t\t\t\tcase \"OutNeighborAdvertisements\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutNeighborAdvertisements = value\n\t\t\t\tcase \"OutRedirects\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutRedirects = value\n\t\t\t\tcase \"OutMLDv2Reports\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutMLDv2Reports = value\n\t\t\t\tcase \"InType1\":\n\t\t\t\t\tprocSnmp6.Icmp6.InType1 = value\n\t\t\t\tcase \"InType134\":\n\t\t\t\t\tprocSnmp6.Icmp6.InType134 = value\n\t\t\t\tcase \"InType135\":\n\t\t\t\t\tprocSnmp6.Icmp6.InType135 = value\n\t\t\t\tcase \"InType136\":\n\t\t\t\t\tprocSnmp6.Icmp6.InType136 = value\n\t\t\t\tcase \"InType143\":\n\t\t\t\t\tprocSnmp6.Icmp6.InType143 = value\n\t\t\t\tcase \"OutType133\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutType133 = value\n\t\t\t\tcase \"OutType135\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutType135 = value\n\t\t\t\tcase \"OutType136\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutType136 = value\n\t\t\t\tcase \"OutType143\":\n\t\t\t\t\tprocSnmp6.Icmp6.OutType143 = value\n\t\t\t\t}\n\t\t\tcase \"Udp6\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InDatagrams\":\n\t\t\t\t\tprocSnmp6.Udp6.InDatagrams = value\n\t\t\t\tcase \"NoPorts\":\n\t\t\t\t\tprocSnmp6.Udp6.NoPorts = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp6.Udp6.InErrors = value\n\t\t\t\tcase \"OutDatagrams\":\n\t\t\t\t\tprocSnmp6.Udp6.OutDatagrams = value\n\t\t\t\tcase \"RcvbufErrors\":\n\t\t\t\t\tprocSnmp6.Udp6.RcvbufErrors = value\n\t\t\t\tcase \"SndbufErrors\":\n\t\t\t\t\tprocSnmp6.Udp6.SndbufErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp6.Udp6.InCsumErrors = value\n\t\t\t\tcase \"IgnoredMulti\":\n\t\t\t\t\tprocSnmp6.Udp6.IgnoredMulti = value\n\t\t\t\t}\n\t\t\tcase \"UdpLite6\":\n\t\t\t\tswitch key {\n\t\t\t\tcase \"InDatagrams\":\n\t\t\t\t\tprocSnmp6.UdpLite6.InDatagrams = value\n\t\t\t\tcase \"NoPorts\":\n\t\t\t\t\tprocSnmp6.UdpLite6.NoPorts = value\n\t\t\t\tcase \"InErrors\":\n\t\t\t\t\tprocSnmp6.UdpLite6.InErrors = value\n\t\t\t\tcase \"OutDatagrams\":\n\t\t\t\t\tprocSnmp6.UdpLite6.OutDatagrams = value\n\t\t\t\tcase \"RcvbufErrors\":\n\t\t\t\t\tprocSnmp6.UdpLite6.RcvbufErrors = value\n\t\t\t\tcase \"SndbufErrors\":\n\t\t\t\t\tprocSnmp6.UdpLite6.SndbufErrors = value\n\t\t\t\tcase \"InCsumErrors\":\n\t\t\t\t\tprocSnmp6.UdpLite6.InCsumErrors = value\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn procSnmp6, scanner.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_stat.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/prometheus/procfs/internal/fs\"\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Originally, this USER_HZ value was dynamically retrieved via a sysconf call\n// which required cgo. However, that caused a lot of problems regarding\n// cross-compilation. Alternatives such as running a binary to determine the\n// value, or trying to derive it in some other way were all problematic. After\n// much research it was determined that USER_HZ is actually hardcoded to 100 on\n// all Go-supported platforms as of the time of this writing. This is why we\n// decided to hardcode it here as well. It is not impossible that there could\n// be systems with exceptions, but they should be very exotic edge cases, and\n// in that case, the worst outcome will be two misreported metrics.\n//\n// See also the following discussions:\n//\n// - https://github.com/prometheus/node_exporter/issues/52\n// - https://github.com/prometheus/procfs/pull/2\n// - http://stackoverflow.com/questions/17410841/how-does-user-hz-solve-the-jiffy-scaling-issue\nconst userHZ = 100\n\n// ProcStat provides status information about the process,\n// read from /proc/[pid]/stat.\ntype ProcStat struct {\n\t// The process ID.\n\tPID int\n\t// The filename of the executable.\n\tComm string\n\t// The process state.\n\tState string\n\t// The PID of the parent of this process.\n\tPPID int\n\t// The process group ID of the process.\n\tPGRP int\n\t// The session ID of the process.\n\tSession int\n\t// The controlling terminal of the process.\n\tTTY int\n\t// The ID of the foreground process group of the controlling terminal of\n\t// the process.\n\tTPGID int\n\t// The kernel flags word of the process.\n\tFlags uint\n\t// The number of minor faults the process has made which have not required\n\t// loading a memory page from disk.\n\tMinFlt uint\n\t// The number of minor faults that the process's waited-for children have\n\t// made.\n\tCMinFlt uint\n\t// The number of major faults the process has made which have required\n\t// loading a memory page from disk.\n\tMajFlt uint\n\t// The number of major faults that the process's waited-for children have\n\t// made.\n\tCMajFlt uint\n\t// Amount of time that this process has been scheduled in user mode,\n\t// measured in clock ticks.\n\tUTime uint\n\t// Amount of time that this process has been scheduled in kernel mode,\n\t// measured in clock ticks.\n\tSTime uint\n\t// Amount of time that this process's waited-for children have been\n\t// scheduled in user mode, measured in clock ticks.\n\tCUTime int\n\t// Amount of time that this process's waited-for children have been\n\t// scheduled in kernel mode, measured in clock ticks.\n\tCSTime int\n\t// For processes running a real-time scheduling policy, this is the negated\n\t// scheduling priority, minus one.\n\tPriority int\n\t// The nice value, a value in the range 19 (low priority) to -20 (high\n\t// priority).\n\tNice int\n\t// Number of threads in this process.\n\tNumThreads int\n\t// The time the process started after system boot, the value is expressed\n\t// in clock ticks.\n\tStarttime uint64\n\t// Virtual memory size in bytes.\n\tVSize uint\n\t// Resident set size in pages.\n\tRSS int\n\t// Soft limit in bytes on the rss of the process.\n\tRSSLimit uint64\n\t// Real-time scheduling priority, a number in the range 1 to 99 for processes\n\t// scheduled under a real-time policy, or 0, for non-real-time processes.\n\tRTPriority uint\n\t// Scheduling policy.\n\tPolicy uint\n\t// Aggregated block I/O delays, measured in clock ticks (centiseconds).\n\tDelayAcctBlkIOTicks uint64\n\n\tproc fs.FS\n}\n\n// NewStat returns the current status information of the process.\n//\n// Deprecated: Use p.Stat() instead.\nfunc (p Proc) NewStat() (ProcStat, error) {\n\treturn p.Stat()\n}\n\n// Stat returns the current status information of the process.\nfunc (p Proc) Stat() (ProcStat, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"stat\"))\n\tif err != nil {\n\t\treturn ProcStat{}, err\n\t}\n\n\tvar (\n\t\tignoreInt64 int64\n\t\tignoreUint64 uint64\n\n\t\ts = ProcStat{PID: p.PID, proc: p.fs}\n\t\tl = bytes.Index(data, []byte(\"(\"))\n\t\tr = bytes.LastIndex(data, []byte(\")\"))\n\t)\n\n\tif l < 0 || r < 0 {\n\t\treturn ProcStat{}, fmt.Errorf(\"unexpected format, couldn't extract comm %q\", data)\n\t}\n\n\ts.Comm = string(data[l+1 : r])\n\n\t// Check the following resources for the details about the particular stat\n\t// fields and their data types:\n\t// * https://man7.org/linux/man-pages/man5/proc.5.html\n\t// * https://man7.org/linux/man-pages/man3/scanf.3.html\n\t_, err = fmt.Fscan(\n\t\tbytes.NewBuffer(data[r+2:]),\n\t\t&s.State,\n\t\t&s.PPID,\n\t\t&s.PGRP,\n\t\t&s.Session,\n\t\t&s.TTY,\n\t\t&s.TPGID,\n\t\t&s.Flags,\n\t\t&s.MinFlt,\n\t\t&s.CMinFlt,\n\t\t&s.MajFlt,\n\t\t&s.CMajFlt,\n\t\t&s.UTime,\n\t\t&s.STime,\n\t\t&s.CUTime,\n\t\t&s.CSTime,\n\t\t&s.Priority,\n\t\t&s.Nice,\n\t\t&s.NumThreads,\n\t\t&ignoreInt64,\n\t\t&s.Starttime,\n\t\t&s.VSize,\n\t\t&s.RSS,\n\t\t&s.RSSLimit,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreUint64,\n\t\t&ignoreInt64,\n\t\t&ignoreInt64,\n\t\t&s.RTPriority,\n\t\t&s.Policy,\n\t\t&s.DelayAcctBlkIOTicks,\n\t)\n\tif err != nil {\n\t\treturn ProcStat{}, err\n\t}\n\n\treturn s, nil\n}\n\n// VirtualMemory returns the virtual memory size in bytes.\nfunc (s ProcStat) VirtualMemory() uint {\n\treturn s.VSize\n}\n\n// ResidentMemory returns the resident memory size in bytes.\nfunc (s ProcStat) ResidentMemory() int {\n\treturn s.RSS * os.Getpagesize()\n}\n\n// StartTime returns the unix timestamp of the process in seconds.\nfunc (s ProcStat) StartTime() (float64, error) {\n\tfs := FS{proc: s.proc}\n\tstat, err := fs.Stat()\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn float64(stat.BootTime) + (float64(s.Starttime) / userHZ), nil\n}\n\n// CPUTime returns the total CPU user and system time in seconds.\nfunc (s ProcStat) CPUTime() float64 {\n\treturn float64(s.UTime+s.STime) / userHZ\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_status.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bytes\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// ProcStatus provides status information about the process,\n// read from /proc/[pid]/stat.\ntype ProcStatus struct {\n\t// The process ID.\n\tPID int\n\t// The process name.\n\tName string\n\n\t// Thread group ID.\n\tTGID int\n\n\t// Peak virtual memory size.\n\tVmPeak uint64 // nolint:revive\n\t// Virtual memory size.\n\tVmSize uint64 // nolint:revive\n\t// Locked memory size.\n\tVmLck uint64 // nolint:revive\n\t// Pinned memory size.\n\tVmPin uint64 // nolint:revive\n\t// Peak resident set size.\n\tVmHWM uint64 // nolint:revive\n\t// Resident set size (sum of RssAnnon RssFile and RssShmem).\n\tVmRSS uint64 // nolint:revive\n\t// Size of resident anonymous memory.\n\tRssAnon uint64 // nolint:revive\n\t// Size of resident file mappings.\n\tRssFile uint64 // nolint:revive\n\t// Size of resident shared memory.\n\tRssShmem uint64 // nolint:revive\n\t// Size of data segments.\n\tVmData uint64 // nolint:revive\n\t// Size of stack segments.\n\tVmStk uint64 // nolint:revive\n\t// Size of text segments.\n\tVmExe uint64 // nolint:revive\n\t// Shared library code size.\n\tVmLib uint64 // nolint:revive\n\t// Page table entries size.\n\tVmPTE uint64 // nolint:revive\n\t// Size of second-level page tables.\n\tVmPMD uint64 // nolint:revive\n\t// Swapped-out virtual memory size by anonymous private.\n\tVmSwap uint64 // nolint:revive\n\t// Size of hugetlb memory portions\n\tHugetlbPages uint64\n\n\t// Number of voluntary context switches.\n\tVoluntaryCtxtSwitches uint64\n\t// Number of involuntary context switches.\n\tNonVoluntaryCtxtSwitches uint64\n\n\t// UIDs of the process (Real, effective, saved set, and filesystem UIDs)\n\tUIDs [4]string\n\t// GIDs of the process (Real, effective, saved set, and filesystem GIDs)\n\tGIDs [4]string\n}\n\n// NewStatus returns the current status information of the process.\nfunc (p Proc) NewStatus() (ProcStatus, error) {\n\tdata, err := util.ReadFileNoStat(p.path(\"status\"))\n\tif err != nil {\n\t\treturn ProcStatus{}, err\n\t}\n\n\ts := ProcStatus{PID: p.PID}\n\n\tlines := strings.Split(string(data), \"\\n\")\n\tfor _, line := range lines {\n\t\tif !bytes.Contains([]byte(line), []byte(\":\")) {\n\t\t\tcontinue\n\t\t}\n\n\t\tkv := strings.SplitN(line, \":\", 2)\n\n\t\t// removes spaces\n\t\tk := string(strings.TrimSpace(kv[0]))\n\t\tv := string(strings.TrimSpace(kv[1]))\n\t\t// removes \"kB\"\n\t\tv = string(bytes.Trim([]byte(v), \" kB\"))\n\n\t\t// value to int when possible\n\t\t// we can skip error check here, 'cause vKBytes is not used when value is a string\n\t\tvKBytes, _ := strconv.ParseUint(v, 10, 64)\n\t\t// convert kB to B\n\t\tvBytes := vKBytes * 1024\n\n\t\ts.fillStatus(k, v, vKBytes, vBytes)\n\t}\n\n\treturn s, nil\n}\n\nfunc (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintBytes uint64) {\n\tswitch k {\n\tcase \"Tgid\":\n\t\ts.TGID = int(vUint)\n\tcase \"Name\":\n\t\ts.Name = vString\n\tcase \"Uid\":\n\t\tcopy(s.UIDs[:], strings.Split(vString, \"\\t\"))\n\tcase \"Gid\":\n\t\tcopy(s.GIDs[:], strings.Split(vString, \"\\t\"))\n\tcase \"VmPeak\":\n\t\ts.VmPeak = vUintBytes\n\tcase \"VmSize\":\n\t\ts.VmSize = vUintBytes\n\tcase \"VmLck\":\n\t\ts.VmLck = vUintBytes\n\tcase \"VmPin\":\n\t\ts.VmPin = vUintBytes\n\tcase \"VmHWM\":\n\t\ts.VmHWM = vUintBytes\n\tcase \"VmRSS\":\n\t\ts.VmRSS = vUintBytes\n\tcase \"RssAnon\":\n\t\ts.RssAnon = vUintBytes\n\tcase \"RssFile\":\n\t\ts.RssFile = vUintBytes\n\tcase \"RssShmem\":\n\t\ts.RssShmem = vUintBytes\n\tcase \"VmData\":\n\t\ts.VmData = vUintBytes\n\tcase \"VmStk\":\n\t\ts.VmStk = vUintBytes\n\tcase \"VmExe\":\n\t\ts.VmExe = vUintBytes\n\tcase \"VmLib\":\n\t\ts.VmLib = vUintBytes\n\tcase \"VmPTE\":\n\t\ts.VmPTE = vUintBytes\n\tcase \"VmPMD\":\n\t\ts.VmPMD = vUintBytes\n\tcase \"VmSwap\":\n\t\ts.VmSwap = vUintBytes\n\tcase \"HugetlbPages\":\n\t\ts.HugetlbPages = vUintBytes\n\tcase \"voluntary_ctxt_switches\":\n\t\ts.VoluntaryCtxtSwitches = vUint\n\tcase \"nonvoluntary_ctxt_switches\":\n\t\ts.NonVoluntaryCtxtSwitches = vUint\n\t}\n}\n\n// TotalCtxtSwitches returns the total context switch.\nfunc (s ProcStatus) TotalCtxtSwitches() uint64 {\n\treturn s.VoluntaryCtxtSwitches + s.NonVoluntaryCtxtSwitches\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/proc_sys.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\nfunc sysctlToPath(sysctl string) string {\n\treturn strings.Replace(sysctl, \".\", \"/\", -1)\n}\n\nfunc (fs FS) SysctlStrings(sysctl string) ([]string, error) {\n\tvalue, err := util.SysReadFile(fs.proc.Path(\"sys\", sysctlToPath(sysctl)))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn strings.Fields(value), nil\n\n}\n\nfunc (fs FS) SysctlInts(sysctl string) ([]int, error) {\n\tfields, err := fs.SysctlStrings(sysctl)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvalues := make([]int, len(fields))\n\tfor i, f := range fields {\n\t\tvp := util.NewValueParser(f)\n\t\tvalues[i] = vp.Int()\n\t\tif err := vp.Err(); err != nil {\n\t\t\treturn nil, fmt.Errorf(\"field %d in sysctl %s is not a valid int: %w\", i, sysctl, err)\n\t\t}\n\t}\n\treturn values, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/schedstat.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"errors\"\n\t\"os\"\n\t\"regexp\"\n\t\"strconv\"\n)\n\nvar (\n\tcpuLineRE = regexp.MustCompile(`cpu(\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (\\d+) (\\d+)`)\n\tprocLineRE = regexp.MustCompile(`(\\d+) (\\d+) (\\d+)`)\n)\n\n// Schedstat contains scheduler statistics from /proc/schedstat\n//\n// See\n// https://www.kernel.org/doc/Documentation/scheduler/sched-stats.txt\n// for a detailed description of what these numbers mean.\n//\n// Note the current kernel documentation claims some of the time units are in\n// jiffies when they are actually in nanoseconds since 2.6.23 with the\n// introduction of CFS. A fix to the documentation is pending. See\n// https://lore.kernel.org/patchwork/project/lkml/list/?series=403473\ntype Schedstat struct {\n\tCPUs []*SchedstatCPU\n}\n\n// SchedstatCPU contains the values from one \"cpu\" line.\ntype SchedstatCPU struct {\n\tCPUNum string\n\n\tRunningNanoseconds uint64\n\tWaitingNanoseconds uint64\n\tRunTimeslices uint64\n}\n\n// ProcSchedstat contains the values from `/proc//schedstat`.\ntype ProcSchedstat struct {\n\tRunningNanoseconds uint64\n\tWaitingNanoseconds uint64\n\tRunTimeslices uint64\n}\n\n// Schedstat reads data from `/proc/schedstat`.\nfunc (fs FS) Schedstat() (*Schedstat, error) {\n\tfile, err := os.Open(fs.proc.Path(\"schedstat\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tdefer file.Close()\n\n\tstats := &Schedstat{}\n\tscanner := bufio.NewScanner(file)\n\n\tfor scanner.Scan() {\n\t\tmatch := cpuLineRE.FindStringSubmatch(scanner.Text())\n\t\tif match != nil {\n\t\t\tcpu := &SchedstatCPU{}\n\t\t\tcpu.CPUNum = match[1]\n\n\t\t\tcpu.RunningNanoseconds, err = strconv.ParseUint(match[8], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tcpu.WaitingNanoseconds, err = strconv.ParseUint(match[9], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tcpu.RunTimeslices, err = strconv.ParseUint(match[10], 10, 64)\n\t\t\tif err != nil {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tstats.CPUs = append(stats.CPUs, cpu)\n\t\t}\n\t}\n\n\treturn stats, nil\n}\n\nfunc parseProcSchedstat(contents string) (ProcSchedstat, error) {\n\tvar (\n\t\tstats ProcSchedstat\n\t\terr error\n\t)\n\tmatch := procLineRE.FindStringSubmatch(contents)\n\n\tif match != nil {\n\t\tstats.RunningNanoseconds, err = strconv.ParseUint(match[1], 10, 64)\n\t\tif err != nil {\n\t\t\treturn stats, err\n\t\t}\n\n\t\tstats.WaitingNanoseconds, err = strconv.ParseUint(match[2], 10, 64)\n\t\tif err != nil {\n\t\t\treturn stats, err\n\t\t}\n\n\t\tstats.RunTimeslices, err = strconv.ParseUint(match[3], 10, 64)\n\t\treturn stats, err\n\t}\n\n\treturn stats, errors.New(\"could not parse schedstat\")\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/slab.go",
"content": "// Copyright 2020 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\nvar (\n\tslabSpace = regexp.MustCompile(`\\s+`)\n\tslabVer = regexp.MustCompile(`slabinfo -`)\n\tslabHeader = regexp.MustCompile(`# name`)\n)\n\n// Slab represents a slab pool in the kernel.\ntype Slab struct {\n\tName string\n\tObjActive int64\n\tObjNum int64\n\tObjSize int64\n\tObjPerSlab int64\n\tPagesPerSlab int64\n\t// tunables\n\tLimit int64\n\tBatch int64\n\tSharedFactor int64\n\tSlabActive int64\n\tSlabNum int64\n\tSharedAvail int64\n}\n\n// SlabInfo represents info for all slabs.\ntype SlabInfo struct {\n\tSlabs []*Slab\n}\n\nfunc shouldParseSlab(line string) bool {\n\tif slabVer.MatchString(line) {\n\t\treturn false\n\t}\n\tif slabHeader.MatchString(line) {\n\t\treturn false\n\t}\n\treturn true\n}\n\n// parseV21SlabEntry is used to parse a line from /proc/slabinfo version 2.1.\nfunc parseV21SlabEntry(line string) (*Slab, error) {\n\t// First cleanup whitespace.\n\tl := slabSpace.ReplaceAllString(line, \" \")\n\ts := strings.Split(l, \" \")\n\tif len(s) != 16 {\n\t\treturn nil, fmt.Errorf(\"unable to parse: %q\", line)\n\t}\n\tvar err error\n\ti := &Slab{Name: s[0]}\n\ti.ObjActive, err = strconv.ParseInt(s[1], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.ObjNum, err = strconv.ParseInt(s[2], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.ObjSize, err = strconv.ParseInt(s[3], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.ObjPerSlab, err = strconv.ParseInt(s[4], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.PagesPerSlab, err = strconv.ParseInt(s[5], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.Limit, err = strconv.ParseInt(s[8], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.Batch, err = strconv.ParseInt(s[9], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.SharedFactor, err = strconv.ParseInt(s[10], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.SlabActive, err = strconv.ParseInt(s[13], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.SlabNum, err = strconv.ParseInt(s[14], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\ti.SharedAvail, err = strconv.ParseInt(s[15], 10, 64)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn i, nil\n}\n\n// parseSlabInfo21 is used to parse a slabinfo 2.1 file.\nfunc parseSlabInfo21(r *bytes.Reader) (SlabInfo, error) {\n\tscanner := bufio.NewScanner(r)\n\ts := SlabInfo{Slabs: []*Slab{}}\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tif !shouldParseSlab(line) {\n\t\t\tcontinue\n\t\t}\n\t\tslab, err := parseV21SlabEntry(line)\n\t\tif err != nil {\n\t\t\treturn s, err\n\t\t}\n\t\ts.Slabs = append(s.Slabs, slab)\n\t}\n\treturn s, nil\n}\n\n// SlabInfo reads data from `/proc/slabinfo`.\nfunc (fs FS) SlabInfo() (SlabInfo, error) {\n\t// TODO: Consider passing options to allow for parsing different\n\t// slabinfo versions. However, slabinfo 2.1 has been stable since\n\t// kernel 2.6.10 and later.\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"slabinfo\"))\n\tif err != nil {\n\t\treturn SlabInfo{}, err\n\t}\n\n\treturn parseSlabInfo21(bytes.NewReader(data))\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/softirqs.go",
"content": "// Copyright 2022 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Softirqs represents the softirq statistics.\ntype Softirqs struct {\n\tHi []uint64\n\tTimer []uint64\n\tNetTx []uint64\n\tNetRx []uint64\n\tBlock []uint64\n\tIRQPoll []uint64\n\tTasklet []uint64\n\tSched []uint64\n\tHRTimer []uint64\n\tRCU []uint64\n}\n\nfunc (fs FS) Softirqs() (Softirqs, error) {\n\tfileName := fs.proc.Path(\"softirqs\")\n\tdata, err := util.ReadFileNoStat(fileName)\n\tif err != nil {\n\t\treturn Softirqs{}, err\n\t}\n\n\treader := bytes.NewReader(data)\n\n\treturn parseSoftirqs(reader)\n}\n\nfunc parseSoftirqs(r io.Reader) (Softirqs, error) {\n\tvar (\n\t\tsoftirqs = Softirqs{}\n\t\tscanner = bufio.NewScanner(r)\n\t)\n\n\tif !scanner.Scan() {\n\t\treturn Softirqs{}, fmt.Errorf(\"softirqs empty\")\n\t}\n\n\tfor scanner.Scan() {\n\t\tparts := strings.Fields(scanner.Text())\n\t\tvar err error\n\n\t\t// require at least one cpu\n\t\tif len(parts) < 2 {\n\t\t\tcontinue\n\t\t}\n\t\tswitch {\n\t\tcase parts[0] == \"HI:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.Hi = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.Hi[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (HI%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"TIMER:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.Timer = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.Timer[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (TIMER%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"NET_TX:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.NetTx = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.NetTx[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (NET_TX%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"NET_RX:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.NetRx = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.NetRx[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (NET_RX%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"BLOCK:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.Block = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.Block[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (BLOCK%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"IRQ_POLL:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.IRQPoll = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.IRQPoll[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (IRQ_POLL%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"TASKLET:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.Tasklet = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.Tasklet[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (TASKLET%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"SCHED:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.Sched = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.Sched[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (SCHED%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"HRTIMER:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.HRTimer = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.HRTimer[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (HRTIMER%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"RCU:\":\n\t\t\tperCPU := parts[1:]\n\t\t\tsoftirqs.RCU = make([]uint64, len(perCPU))\n\t\t\tfor i, count := range perCPU {\n\t\t\t\tif softirqs.RCU[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse %q (RCU%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif err := scanner.Err(); err != nil {\n\t\treturn Softirqs{}, fmt.Errorf(\"couldn't parse softirqs: %w\", err)\n\t}\n\n\treturn softirqs, scanner.Err()\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/stat.go",
"content": "// Copyright 2018 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/fs\"\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// CPUStat shows how much time the cpu spend in various stages.\ntype CPUStat struct {\n\tUser float64\n\tNice float64\n\tSystem float64\n\tIdle float64\n\tIowait float64\n\tIRQ float64\n\tSoftIRQ float64\n\tSteal float64\n\tGuest float64\n\tGuestNice float64\n}\n\n// SoftIRQStat represent the softirq statistics as exported in the procfs stat file.\n// A nice introduction can be found at https://0xax.gitbooks.io/linux-insides/content/interrupts/interrupts-9.html\n// It is possible to get per-cpu stats by reading `/proc/softirqs`.\ntype SoftIRQStat struct {\n\tHi uint64\n\tTimer uint64\n\tNetTx uint64\n\tNetRx uint64\n\tBlock uint64\n\tBlockIoPoll uint64\n\tTasklet uint64\n\tSched uint64\n\tHrtimer uint64\n\tRcu uint64\n}\n\n// Stat represents kernel/system statistics.\ntype Stat struct {\n\t// Boot time in seconds since the Epoch.\n\tBootTime uint64\n\t// Summed up cpu statistics.\n\tCPUTotal CPUStat\n\t// Per-CPU statistics.\n\tCPU []CPUStat\n\t// Number of times interrupts were handled, which contains numbered and unnumbered IRQs.\n\tIRQTotal uint64\n\t// Number of times a numbered IRQ was triggered.\n\tIRQ []uint64\n\t// Number of times a context switch happened.\n\tContextSwitches uint64\n\t// Number of times a process was created.\n\tProcessCreated uint64\n\t// Number of processes currently running.\n\tProcessesRunning uint64\n\t// Number of processes currently blocked (waiting for IO).\n\tProcessesBlocked uint64\n\t// Number of times a softirq was scheduled.\n\tSoftIRQTotal uint64\n\t// Detailed softirq statistics.\n\tSoftIRQ SoftIRQStat\n}\n\n// Parse a cpu statistics line and returns the CPUStat struct plus the cpu id (or -1 for the overall sum).\nfunc parseCPUStat(line string) (CPUStat, int64, error) {\n\tcpuStat := CPUStat{}\n\tvar cpu string\n\n\tcount, err := fmt.Sscanf(line, \"%s %f %f %f %f %f %f %f %f %f %f\",\n\t\t&cpu,\n\t\t&cpuStat.User, &cpuStat.Nice, &cpuStat.System, &cpuStat.Idle,\n\t\t&cpuStat.Iowait, &cpuStat.IRQ, &cpuStat.SoftIRQ, &cpuStat.Steal,\n\t\t&cpuStat.Guest, &cpuStat.GuestNice)\n\n\tif err != nil && err != io.EOF {\n\t\treturn CPUStat{}, -1, fmt.Errorf(\"couldn't parse %q (cpu): %w\", line, err)\n\t}\n\tif count == 0 {\n\t\treturn CPUStat{}, -1, fmt.Errorf(\"couldn't parse %q (cpu): 0 elements parsed\", line)\n\t}\n\n\tcpuStat.User /= userHZ\n\tcpuStat.Nice /= userHZ\n\tcpuStat.System /= userHZ\n\tcpuStat.Idle /= userHZ\n\tcpuStat.Iowait /= userHZ\n\tcpuStat.IRQ /= userHZ\n\tcpuStat.SoftIRQ /= userHZ\n\tcpuStat.Steal /= userHZ\n\tcpuStat.Guest /= userHZ\n\tcpuStat.GuestNice /= userHZ\n\n\tif cpu == \"cpu\" {\n\t\treturn cpuStat, -1, nil\n\t}\n\n\tcpuID, err := strconv.ParseInt(cpu[3:], 10, 64)\n\tif err != nil {\n\t\treturn CPUStat{}, -1, fmt.Errorf(\"couldn't parse %q (cpu/cpuid): %w\", line, err)\n\t}\n\n\treturn cpuStat, cpuID, nil\n}\n\n// Parse a softirq line.\nfunc parseSoftIRQStat(line string) (SoftIRQStat, uint64, error) {\n\tsoftIRQStat := SoftIRQStat{}\n\tvar total uint64\n\tvar prefix string\n\n\t_, err := fmt.Sscanf(line, \"%s %d %d %d %d %d %d %d %d %d %d %d\",\n\t\t&prefix, &total,\n\t\t&softIRQStat.Hi, &softIRQStat.Timer, &softIRQStat.NetTx, &softIRQStat.NetRx,\n\t\t&softIRQStat.Block, &softIRQStat.BlockIoPoll,\n\t\t&softIRQStat.Tasklet, &softIRQStat.Sched,\n\t\t&softIRQStat.Hrtimer, &softIRQStat.Rcu)\n\n\tif err != nil {\n\t\treturn SoftIRQStat{}, 0, fmt.Errorf(\"couldn't parse %q (softirq): %w\", line, err)\n\t}\n\n\treturn softIRQStat, total, nil\n}\n\n// NewStat returns information about current cpu/process statistics.\n// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt\n//\n// Deprecated: Use fs.Stat() instead.\nfunc NewStat() (Stat, error) {\n\tfs, err := NewFS(fs.DefaultProcMountPoint)\n\tif err != nil {\n\t\treturn Stat{}, err\n\t}\n\treturn fs.Stat()\n}\n\n// NewStat returns information about current cpu/process statistics.\n// See: https://www.kernel.org/doc/Documentation/filesystems/proc.txt\n//\n// Deprecated: Use fs.Stat() instead.\nfunc (fs FS) NewStat() (Stat, error) {\n\treturn fs.Stat()\n}\n\n// Stat returns information about current cpu/process statistics.\n// See: https://www.kernel.org/doc/Documentation/filesystems/proc.txt\nfunc (fs FS) Stat() (Stat, error) {\n\tfileName := fs.proc.Path(\"stat\")\n\tdata, err := util.ReadFileNoStat(fileName)\n\tif err != nil {\n\t\treturn Stat{}, err\n\t}\n\n\tstat := Stat{}\n\n\tscanner := bufio.NewScanner(bytes.NewReader(data))\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\t\tparts := strings.Fields(scanner.Text())\n\t\t// require at least \n\t\tif len(parts) < 2 {\n\t\t\tcontinue\n\t\t}\n\t\tswitch {\n\t\tcase parts[0] == \"btime\":\n\t\t\tif stat.BootTime, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (btime): %w\", parts[1], err)\n\t\t\t}\n\t\tcase parts[0] == \"intr\":\n\t\t\tif stat.IRQTotal, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (intr): %w\", parts[1], err)\n\t\t\t}\n\t\t\tnumberedIRQs := parts[2:]\n\t\t\tstat.IRQ = make([]uint64, len(numberedIRQs))\n\t\t\tfor i, count := range numberedIRQs {\n\t\t\t\tif stat.IRQ[i], err = strconv.ParseUint(count, 10, 64); err != nil {\n\t\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (intr%d): %w\", count, i, err)\n\t\t\t\t}\n\t\t\t}\n\t\tcase parts[0] == \"ctxt\":\n\t\t\tif stat.ContextSwitches, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (ctxt): %w\", parts[1], err)\n\t\t\t}\n\t\tcase parts[0] == \"processes\":\n\t\t\tif stat.ProcessCreated, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (processes): %w\", parts[1], err)\n\t\t\t}\n\t\tcase parts[0] == \"procs_running\":\n\t\t\tif stat.ProcessesRunning, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (procs_running): %w\", parts[1], err)\n\t\t\t}\n\t\tcase parts[0] == \"procs_blocked\":\n\t\t\tif stat.ProcessesBlocked, err = strconv.ParseUint(parts[1], 10, 64); err != nil {\n\t\t\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q (procs_blocked): %w\", parts[1], err)\n\t\t\t}\n\t\tcase parts[0] == \"softirq\":\n\t\t\tsoftIRQStats, total, err := parseSoftIRQStat(line)\n\t\t\tif err != nil {\n\t\t\t\treturn Stat{}, err\n\t\t\t}\n\t\t\tstat.SoftIRQTotal = total\n\t\t\tstat.SoftIRQ = softIRQStats\n\t\tcase strings.HasPrefix(parts[0], \"cpu\"):\n\t\t\tcpuStat, cpuID, err := parseCPUStat(line)\n\t\t\tif err != nil {\n\t\t\t\treturn Stat{}, err\n\t\t\t}\n\t\t\tif cpuID == -1 {\n\t\t\t\tstat.CPUTotal = cpuStat\n\t\t\t} else {\n\t\t\t\tfor int64(len(stat.CPU)) <= cpuID {\n\t\t\t\t\tstat.CPU = append(stat.CPU, CPUStat{})\n\t\t\t\t}\n\t\t\t\tstat.CPU[cpuID] = cpuStat\n\t\t\t}\n\t\t}\n\t}\n\n\tif err := scanner.Err(); err != nil {\n\t\treturn Stat{}, fmt.Errorf(\"couldn't parse %q: %w\", fileName, err)\n\t}\n\n\treturn stat, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/swaps.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage procfs\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Swap represents an entry in /proc/swaps.\ntype Swap struct {\n\tFilename string\n\tType string\n\tSize int\n\tUsed int\n\tPriority int\n}\n\n// Swaps returns a slice of all configured swap devices on the system.\nfunc (fs FS) Swaps() ([]*Swap, error) {\n\tdata, err := util.ReadFileNoStat(fs.proc.Path(\"swaps\"))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn parseSwaps(data)\n}\n\nfunc parseSwaps(info []byte) ([]*Swap, error) {\n\tswaps := []*Swap{}\n\tscanner := bufio.NewScanner(bytes.NewReader(info))\n\tscanner.Scan() // ignore header line\n\tfor scanner.Scan() {\n\t\tswapString := scanner.Text()\n\t\tparsedSwap, err := parseSwapString(swapString)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tswaps = append(swaps, parsedSwap)\n\t}\n\n\terr := scanner.Err()\n\treturn swaps, err\n}\n\nfunc parseSwapString(swapString string) (*Swap, error) {\n\tvar err error\n\n\tswapFields := strings.Fields(swapString)\n\tswapLength := len(swapFields)\n\tif swapLength < 5 {\n\t\treturn nil, fmt.Errorf(\"too few fields in swap string: %s\", swapString)\n\t}\n\n\tswap := &Swap{\n\t\tFilename: swapFields[0],\n\t\tType: swapFields[1],\n\t}\n\n\tswap.Size, err = strconv.Atoi(swapFields[2])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"invalid swap size: %s\", swapFields[2])\n\t}\n\tswap.Used, err = strconv.Atoi(swapFields[3])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"invalid swap used: %s\", swapFields[3])\n\t}\n\tswap.Priority, err = strconv.Atoi(swapFields[4])\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"invalid swap priority: %s\", swapFields[4])\n\t}\n\n\treturn swap, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/ttar",
"content": "#!/usr/bin/env bash\n\n# Purpose: plain text tar format\n# Limitations: - only suitable for text files, directories, and symlinks\n# - stores only filename, content, and mode\n# - not designed for untrusted input\n#\n# Note: must work with bash version 3.2 (macOS)\n\n# Copyright 2017 Roger Luethi\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nset -o errexit -o nounset\n\n# Sanitize environment (for instance, standard sorting of glob matches)\nexport LC_ALL=C\n\npath=\"\"\nCMD=\"\"\nARG_STRING=\"$*\"\n\n#------------------------------------------------------------------------------\n# Not all sed implementations can work on null bytes. In order to make ttar\n# work out of the box on macOS, use Python as a stream editor.\n\nUSE_PYTHON=0\n\nPYTHON_CREATE_FILTER=$(cat << 'PCF'\n#!/usr/bin/env python\n\nimport re\nimport sys\n\nfor line in sys.stdin:\n line = re.sub(r'EOF', r'\\EOF', line)\n line = re.sub(r'NULLBYTE', r'\\NULLBYTE', line)\n line = re.sub('\\x00', r'NULLBYTE', line)\n sys.stdout.write(line)\nPCF\n)\n\nPYTHON_EXTRACT_FILTER=$(cat << 'PEF'\n#!/usr/bin/env python\n\nimport re\nimport sys\n\nfor line in sys.stdin:\n line = re.sub(r'(?/dev/null; then\n echo \"ERROR Python not found. Aborting.\"\n exit 2\n fi\n USE_PYTHON=1\n fi\n}\n\n#------------------------------------------------------------------------------\n\nfunction usage {\n bname=$(basename \"$0\")\n cat << USAGE\nUsage: $bname [-C ] -c -f (create archive)\n $bname -t -f (list archive contents)\n $bname [-C ] -x -f (extract archive)\n\nOptions:\n -C (change directory)\n -v (verbose)\n --recursive-unlink (recursively delete existing directory if path\n collides with file or directory to extract)\n\nExample: Change to sysfs directory, create ttar file from fixtures directory\n $bname -C sysfs -c -f sysfs/fixtures.ttar fixtures/\nUSAGE\nexit \"$1\"\n}\n\nfunction vecho {\n if [ \"${VERBOSE:-}\" == \"yes\" ]; then\n echo >&7 \"$@\"\n fi\n}\n\nfunction set_cmd {\n if [ -n \"$CMD\" ]; then\n echo \"ERROR: more than one command given\"\n echo\n usage 2\n fi\n CMD=$1\n}\n\nunset VERBOSE\nunset RECURSIVE_UNLINK\n\nwhile getopts :cf:-:htxvC: opt; do\n case $opt in\n c)\n set_cmd \"create\"\n ;;\n f)\n ARCHIVE=$OPTARG\n ;;\n h)\n usage 0\n ;;\n t)\n set_cmd \"list\"\n ;;\n x)\n set_cmd \"extract\"\n ;;\n v)\n VERBOSE=yes\n exec 7>&1\n ;;\n C)\n CDIR=$OPTARG\n ;;\n -)\n case $OPTARG in\n recursive-unlink)\n RECURSIVE_UNLINK=\"yes\"\n ;;\n *)\n echo -e \"Error: invalid option -$OPTARG\"\n echo\n usage 1\n ;;\n esac\n ;;\n *)\n echo >&2 \"ERROR: invalid option -$OPTARG\"\n echo\n usage 1\n ;;\n esac\ndone\n\n# Remove processed options from arguments\nshift $(( OPTIND - 1 ));\n\nif [ \"${CMD:-}\" == \"\" ]; then\n echo >&2 \"ERROR: no command given\"\n echo\n usage 1\nelif [ \"${ARCHIVE:-}\" == \"\" ]; then\n echo >&2 \"ERROR: no archive name given\"\n echo\n usage 1\nfi\n\nfunction list {\n local path=\"\"\n local size=0\n local line_no=0\n local ttar_file=$1\n if [ -n \"${2:-}\" ]; then\n echo >&2 \"ERROR: too many arguments.\"\n echo\n usage 1\n fi\n if [ ! -e \"$ttar_file\" ]; then\n echo >&2 \"ERROR: file not found ($ttar_file)\"\n echo\n usage 1\n fi\n while read -r line; do\n line_no=$(( line_no + 1 ))\n if [ $size -gt 0 ]; then\n size=$(( size - 1 ))\n continue\n fi\n if [[ $line =~ ^Path:\\ (.*)$ ]]; then\n path=${BASH_REMATCH[1]}\n elif [[ $line =~ ^Lines:\\ (.*)$ ]]; then\n size=${BASH_REMATCH[1]}\n echo \"$path\"\n elif [[ $line =~ ^Directory:\\ (.*)$ ]]; then\n path=${BASH_REMATCH[1]}\n echo \"$path/\"\n elif [[ $line =~ ^SymlinkTo:\\ (.*)$ ]]; then\n echo \"$path -> ${BASH_REMATCH[1]}\"\n fi\n done < \"$ttar_file\"\n}\n\nfunction extract {\n local path=\"\"\n local size=0\n local line_no=0\n local ttar_file=$1\n if [ -n \"${2:-}\" ]; then\n echo >&2 \"ERROR: too many arguments.\"\n echo\n usage 1\n fi\n if [ ! -e \"$ttar_file\" ]; then\n echo >&2 \"ERROR: file not found ($ttar_file)\"\n echo\n usage 1\n fi\n while IFS= read -r line; do\n line_no=$(( line_no + 1 ))\n local eof_without_newline\n if [ \"$size\" -gt 0 ]; then\n if [[ \"$line\" =~ [^\\\\]EOF ]]; then\n # An EOF not preceded by a backslash indicates that the line\n # does not end with a newline\n eof_without_newline=1\n else\n eof_without_newline=0\n fi\n # Replace NULLBYTE with null byte if at beginning of line\n # Replace NULLBYTE with null byte unless preceded by backslash\n # Remove one backslash in front of NULLBYTE (if any)\n # Remove EOF unless preceded by backslash\n # Remove one backslash in front of EOF\n if [ $USE_PYTHON -eq 1 ]; then\n echo -n \"$line\" | python -c \"$PYTHON_EXTRACT_FILTER\" >> \"$path\"\n else\n # The repeated pattern makes up for sed's lack of negative\n # lookbehind assertions (for consecutive null bytes).\n echo -n \"$line\" | \\\n sed -e 's/^NULLBYTE/\\x0/g;\n s/\\([^\\\\]\\)NULLBYTE/\\1\\x0/g;\n s/\\([^\\\\]\\)NULLBYTE/\\1\\x0/g;\n s/\\\\NULLBYTE/NULLBYTE/g;\n s/\\([^\\\\]\\)EOF/\\1/g;\n s/\\\\EOF/EOF/g;\n ' >> \"$path\"\n fi\n if [[ \"$eof_without_newline\" -eq 0 ]]; then\n echo >> \"$path\"\n fi\n size=$(( size - 1 ))\n continue\n fi\n if [[ $line =~ ^Path:\\ (.*)$ ]]; then\n path=${BASH_REMATCH[1]}\n if [ -L \"$path\" ]; then\n rm \"$path\"\n elif [ -d \"$path\" ]; then\n if [ \"${RECURSIVE_UNLINK:-}\" == \"yes\" ]; then\n rm -r \"$path\"\n else\n # Safe because symlinks to directories are dealt with above\n rmdir \"$path\"\n fi\n elif [ -e \"$path\" ]; then\n rm \"$path\"\n fi\n elif [[ $line =~ ^Lines:\\ (.*)$ ]]; then\n size=${BASH_REMATCH[1]}\n # Create file even if it is zero-length.\n touch \"$path\"\n vecho \" $path\"\n elif [[ $line =~ ^Mode:\\ (.*)$ ]]; then\n mode=${BASH_REMATCH[1]}\n chmod \"$mode\" \"$path\"\n vecho \"$mode\"\n elif [[ $line =~ ^Directory:\\ (.*)$ ]]; then\n path=${BASH_REMATCH[1]}\n mkdir -p \"$path\"\n vecho \" $path/\"\n elif [[ $line =~ ^SymlinkTo:\\ (.*)$ ]]; then\n ln -s \"${BASH_REMATCH[1]}\" \"$path\"\n vecho \" $path -> ${BASH_REMATCH[1]}\"\n elif [[ $line =~ ^# ]]; then\n # Ignore comments between files\n continue\n else\n echo >&2 \"ERROR: Unknown keyword on line $line_no: $line\"\n exit 1\n fi\n done < \"$ttar_file\"\n}\n\nfunction div {\n echo \"# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\" \\\n \"- - - - - -\"\n}\n\nfunction get_mode {\n local mfile=$1\n if [ -z \"${STAT_OPTION:-}\" ]; then\n if stat -c '%a' \"$mfile\" >/dev/null 2>&1; then\n # GNU stat\n STAT_OPTION='-c'\n STAT_FORMAT='%a'\n else\n # BSD stat\n STAT_OPTION='-f'\n # Octal output, user/group/other (omit file type, sticky bit)\n STAT_FORMAT='%OLp'\n fi\n fi\n stat \"${STAT_OPTION}\" \"${STAT_FORMAT}\" \"$mfile\"\n}\n\nfunction _create {\n shopt -s nullglob\n local mode\n local eof_without_newline\n while (( \"$#\" )); do\n file=$1\n if [ -L \"$file\" ]; then\n echo \"Path: $file\"\n symlinkTo=$(readlink \"$file\")\n echo \"SymlinkTo: $symlinkTo\"\n vecho \" $file -> $symlinkTo\"\n div\n elif [ -d \"$file\" ]; then\n # Strip trailing slash (if there is one)\n file=${file%/}\n echo \"Directory: $file\"\n mode=$(get_mode \"$file\")\n echo \"Mode: $mode\"\n vecho \"$mode $file/\"\n div\n # Find all files and dirs, including hidden/dot files\n for x in \"$file/\"{*,.[^.]*}; do\n _create \"$x\"\n done\n elif [ -f \"$file\" ]; then\n echo \"Path: $file\"\n lines=$(wc -l \"$file\"|awk '{print $1}')\n eof_without_newline=0\n if [[ \"$(wc -c \"$file\"|awk '{print $1}')\" -gt 0 ]] && \\\n [[ \"$(tail -c 1 \"$file\" | wc -l)\" -eq 0 ]]; then\n eof_without_newline=1\n lines=$((lines+1))\n fi\n echo \"Lines: $lines\"\n # Add backslash in front of EOF\n # Add backslash in front of NULLBYTE\n # Replace null byte with NULLBYTE\n if [ $USE_PYTHON -eq 1 ]; then\n < \"$file\" python -c \"$PYTHON_CREATE_FILTER\"\n else\n < \"$file\" \\\n sed 's/EOF/\\\\EOF/g;\n s/NULLBYTE/\\\\NULLBYTE/g;\n s/\\x0/NULLBYTE/g;\n '\n fi\n if [[ \"$eof_without_newline\" -eq 1 ]]; then\n # Finish line with EOF to indicate that the original line did\n # not end with a linefeed\n echo \"EOF\"\n fi\n mode=$(get_mode \"$file\")\n echo \"Mode: $mode\"\n vecho \"$mode $file\"\n div\n else\n echo >&2 \"ERROR: file not found ($file in $(pwd))\"\n exit 2\n fi\n shift\n done\n}\n\nfunction create {\n ttar_file=$1\n shift\n if [ -z \"${1:-}\" ]; then\n echo >&2 \"ERROR: missing arguments.\"\n echo\n usage 1\n fi\n if [ -e \"$ttar_file\" ]; then\n rm \"$ttar_file\"\n fi\n exec > \"$ttar_file\"\n echo \"# Archive created by ttar $ARG_STRING\"\n _create \"$@\"\n}\n\ntest_environment\n\nif [ -n \"${CDIR:-}\" ]; then\n if [[ \"$ARCHIVE\" != /* ]]; then\n # Relative path: preserve the archive's location before changing\n # directory\n ARCHIVE=\"$(pwd)/$ARCHIVE\"\n fi\n cd \"$CDIR\"\nfi\n\n\"$CMD\" \"$ARCHIVE\" \"$@\"\n"
},
{
"path": "vendor/github.com/prometheus/procfs/vm.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows\n// +build !windows\n\npackage procfs\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// The VM interface is described at\n// https://www.kernel.org/doc/Documentation/sysctl/vm.txt\n// Each setting is exposed as a single file.\n// Each file contains one line with a single numerical value, except lowmem_reserve_ratio which holds an array\n// and numa_zonelist_order (deprecated) which is a string.\ntype VM struct {\n\tAdminReserveKbytes *int64 // /proc/sys/vm/admin_reserve_kbytes\n\tBlockDump *int64 // /proc/sys/vm/block_dump\n\tCompactUnevictableAllowed *int64 // /proc/sys/vm/compact_unevictable_allowed\n\tDirtyBackgroundBytes *int64 // /proc/sys/vm/dirty_background_bytes\n\tDirtyBackgroundRatio *int64 // /proc/sys/vm/dirty_background_ratio\n\tDirtyBytes *int64 // /proc/sys/vm/dirty_bytes\n\tDirtyExpireCentisecs *int64 // /proc/sys/vm/dirty_expire_centisecs\n\tDirtyRatio *int64 // /proc/sys/vm/dirty_ratio\n\tDirtytimeExpireSeconds *int64 // /proc/sys/vm/dirtytime_expire_seconds\n\tDirtyWritebackCentisecs *int64 // /proc/sys/vm/dirty_writeback_centisecs\n\tDropCaches *int64 // /proc/sys/vm/drop_caches\n\tExtfragThreshold *int64 // /proc/sys/vm/extfrag_threshold\n\tHugetlbShmGroup *int64 // /proc/sys/vm/hugetlb_shm_group\n\tLaptopMode *int64 // /proc/sys/vm/laptop_mode\n\tLegacyVaLayout *int64 // /proc/sys/vm/legacy_va_layout\n\tLowmemReserveRatio []*int64 // /proc/sys/vm/lowmem_reserve_ratio\n\tMaxMapCount *int64 // /proc/sys/vm/max_map_count\n\tMemoryFailureEarlyKill *int64 // /proc/sys/vm/memory_failure_early_kill\n\tMemoryFailureRecovery *int64 // /proc/sys/vm/memory_failure_recovery\n\tMinFreeKbytes *int64 // /proc/sys/vm/min_free_kbytes\n\tMinSlabRatio *int64 // /proc/sys/vm/min_slab_ratio\n\tMinUnmappedRatio *int64 // /proc/sys/vm/min_unmapped_ratio\n\tMmapMinAddr *int64 // /proc/sys/vm/mmap_min_addr\n\tNrHugepages *int64 // /proc/sys/vm/nr_hugepages\n\tNrHugepagesMempolicy *int64 // /proc/sys/vm/nr_hugepages_mempolicy\n\tNrOvercommitHugepages *int64 // /proc/sys/vm/nr_overcommit_hugepages\n\tNumaStat *int64 // /proc/sys/vm/numa_stat\n\tNumaZonelistOrder string // /proc/sys/vm/numa_zonelist_order\n\tOomDumpTasks *int64 // /proc/sys/vm/oom_dump_tasks\n\tOomKillAllocatingTask *int64 // /proc/sys/vm/oom_kill_allocating_task\n\tOvercommitKbytes *int64 // /proc/sys/vm/overcommit_kbytes\n\tOvercommitMemory *int64 // /proc/sys/vm/overcommit_memory\n\tOvercommitRatio *int64 // /proc/sys/vm/overcommit_ratio\n\tPageCluster *int64 // /proc/sys/vm/page-cluster\n\tPanicOnOom *int64 // /proc/sys/vm/panic_on_oom\n\tPercpuPagelistFraction *int64 // /proc/sys/vm/percpu_pagelist_fraction\n\tStatInterval *int64 // /proc/sys/vm/stat_interval\n\tSwappiness *int64 // /proc/sys/vm/swappiness\n\tUserReserveKbytes *int64 // /proc/sys/vm/user_reserve_kbytes\n\tVfsCachePressure *int64 // /proc/sys/vm/vfs_cache_pressure\n\tWatermarkBoostFactor *int64 // /proc/sys/vm/watermark_boost_factor\n\tWatermarkScaleFactor *int64 // /proc/sys/vm/watermark_scale_factor\n\tZoneReclaimMode *int64 // /proc/sys/vm/zone_reclaim_mode\n}\n\n// VM reads the VM statistics from the specified `proc` filesystem.\nfunc (fs FS) VM() (*VM, error) {\n\tpath := fs.proc.Path(\"sys/vm\")\n\tfile, err := os.Stat(path)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tif !file.Mode().IsDir() {\n\t\treturn nil, fmt.Errorf(\"%s is not a directory\", path)\n\t}\n\n\tfiles, err := os.ReadDir(path)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar vm VM\n\tfor _, f := range files {\n\t\tif f.IsDir() {\n\t\t\tcontinue\n\t\t}\n\n\t\tname := filepath.Join(path, f.Name())\n\t\t// ignore errors on read, as there are some write only\n\t\t// in /proc/sys/vm\n\t\tvalue, err := util.SysReadFile(name)\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\tvp := util.NewValueParser(value)\n\n\t\tswitch f.Name() {\n\t\tcase \"admin_reserve_kbytes\":\n\t\t\tvm.AdminReserveKbytes = vp.PInt64()\n\t\tcase \"block_dump\":\n\t\t\tvm.BlockDump = vp.PInt64()\n\t\tcase \"compact_unevictable_allowed\":\n\t\t\tvm.CompactUnevictableAllowed = vp.PInt64()\n\t\tcase \"dirty_background_bytes\":\n\t\t\tvm.DirtyBackgroundBytes = vp.PInt64()\n\t\tcase \"dirty_background_ratio\":\n\t\t\tvm.DirtyBackgroundRatio = vp.PInt64()\n\t\tcase \"dirty_bytes\":\n\t\t\tvm.DirtyBytes = vp.PInt64()\n\t\tcase \"dirty_expire_centisecs\":\n\t\t\tvm.DirtyExpireCentisecs = vp.PInt64()\n\t\tcase \"dirty_ratio\":\n\t\t\tvm.DirtyRatio = vp.PInt64()\n\t\tcase \"dirtytime_expire_seconds\":\n\t\t\tvm.DirtytimeExpireSeconds = vp.PInt64()\n\t\tcase \"dirty_writeback_centisecs\":\n\t\t\tvm.DirtyWritebackCentisecs = vp.PInt64()\n\t\tcase \"drop_caches\":\n\t\t\tvm.DropCaches = vp.PInt64()\n\t\tcase \"extfrag_threshold\":\n\t\t\tvm.ExtfragThreshold = vp.PInt64()\n\t\tcase \"hugetlb_shm_group\":\n\t\t\tvm.HugetlbShmGroup = vp.PInt64()\n\t\tcase \"laptop_mode\":\n\t\t\tvm.LaptopMode = vp.PInt64()\n\t\tcase \"legacy_va_layout\":\n\t\t\tvm.LegacyVaLayout = vp.PInt64()\n\t\tcase \"lowmem_reserve_ratio\":\n\t\t\tstringSlice := strings.Fields(value)\n\t\t\tpint64Slice := make([]*int64, 0, len(stringSlice))\n\t\t\tfor _, value := range stringSlice {\n\t\t\t\tvp := util.NewValueParser(value)\n\t\t\t\tpint64Slice = append(pint64Slice, vp.PInt64())\n\t\t\t}\n\t\t\tvm.LowmemReserveRatio = pint64Slice\n\t\tcase \"max_map_count\":\n\t\t\tvm.MaxMapCount = vp.PInt64()\n\t\tcase \"memory_failure_early_kill\":\n\t\t\tvm.MemoryFailureEarlyKill = vp.PInt64()\n\t\tcase \"memory_failure_recovery\":\n\t\t\tvm.MemoryFailureRecovery = vp.PInt64()\n\t\tcase \"min_free_kbytes\":\n\t\t\tvm.MinFreeKbytes = vp.PInt64()\n\t\tcase \"min_slab_ratio\":\n\t\t\tvm.MinSlabRatio = vp.PInt64()\n\t\tcase \"min_unmapped_ratio\":\n\t\t\tvm.MinUnmappedRatio = vp.PInt64()\n\t\tcase \"mmap_min_addr\":\n\t\t\tvm.MmapMinAddr = vp.PInt64()\n\t\tcase \"nr_hugepages\":\n\t\t\tvm.NrHugepages = vp.PInt64()\n\t\tcase \"nr_hugepages_mempolicy\":\n\t\t\tvm.NrHugepagesMempolicy = vp.PInt64()\n\t\tcase \"nr_overcommit_hugepages\":\n\t\t\tvm.NrOvercommitHugepages = vp.PInt64()\n\t\tcase \"numa_stat\":\n\t\t\tvm.NumaStat = vp.PInt64()\n\t\tcase \"numa_zonelist_order\":\n\t\t\tvm.NumaZonelistOrder = value\n\t\tcase \"oom_dump_tasks\":\n\t\t\tvm.OomDumpTasks = vp.PInt64()\n\t\tcase \"oom_kill_allocating_task\":\n\t\t\tvm.OomKillAllocatingTask = vp.PInt64()\n\t\tcase \"overcommit_kbytes\":\n\t\t\tvm.OvercommitKbytes = vp.PInt64()\n\t\tcase \"overcommit_memory\":\n\t\t\tvm.OvercommitMemory = vp.PInt64()\n\t\tcase \"overcommit_ratio\":\n\t\t\tvm.OvercommitRatio = vp.PInt64()\n\t\tcase \"page-cluster\":\n\t\t\tvm.PageCluster = vp.PInt64()\n\t\tcase \"panic_on_oom\":\n\t\t\tvm.PanicOnOom = vp.PInt64()\n\t\tcase \"percpu_pagelist_fraction\":\n\t\t\tvm.PercpuPagelistFraction = vp.PInt64()\n\t\tcase \"stat_interval\":\n\t\t\tvm.StatInterval = vp.PInt64()\n\t\tcase \"swappiness\":\n\t\t\tvm.Swappiness = vp.PInt64()\n\t\tcase \"user_reserve_kbytes\":\n\t\t\tvm.UserReserveKbytes = vp.PInt64()\n\t\tcase \"vfs_cache_pressure\":\n\t\t\tvm.VfsCachePressure = vp.PInt64()\n\t\tcase \"watermark_boost_factor\":\n\t\t\tvm.WatermarkBoostFactor = vp.PInt64()\n\t\tcase \"watermark_scale_factor\":\n\t\t\tvm.WatermarkScaleFactor = vp.PInt64()\n\t\tcase \"zone_reclaim_mode\":\n\t\t\tvm.ZoneReclaimMode = vp.PInt64()\n\t\t}\n\t\tif err := vp.Err(); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\treturn &vm, nil\n}\n"
},
{
"path": "vendor/github.com/prometheus/procfs/zoneinfo.go",
"content": "// Copyright 2019 The Prometheus Authors\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows\n// +build !windows\n\npackage procfs\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strings\"\n\n\t\"github.com/prometheus/procfs/internal/util\"\n)\n\n// Zoneinfo holds info parsed from /proc/zoneinfo.\ntype Zoneinfo struct {\n\tNode string\n\tZone string\n\tNrFreePages *int64\n\tMin *int64\n\tLow *int64\n\tHigh *int64\n\tScanned *int64\n\tSpanned *int64\n\tPresent *int64\n\tManaged *int64\n\tNrActiveAnon *int64\n\tNrInactiveAnon *int64\n\tNrIsolatedAnon *int64\n\tNrAnonPages *int64\n\tNrAnonTransparentHugepages *int64\n\tNrActiveFile *int64\n\tNrInactiveFile *int64\n\tNrIsolatedFile *int64\n\tNrFilePages *int64\n\tNrSlabReclaimable *int64\n\tNrSlabUnreclaimable *int64\n\tNrMlockStack *int64\n\tNrKernelStack *int64\n\tNrMapped *int64\n\tNrDirty *int64\n\tNrWriteback *int64\n\tNrUnevictable *int64\n\tNrShmem *int64\n\tNrDirtied *int64\n\tNrWritten *int64\n\tNumaHit *int64\n\tNumaMiss *int64\n\tNumaForeign *int64\n\tNumaInterleave *int64\n\tNumaLocal *int64\n\tNumaOther *int64\n\tProtection []*int64\n}\n\nvar nodeZoneRE = regexp.MustCompile(`(\\d+), zone\\s+(\\w+)`)\n\n// Zoneinfo parses an zoneinfo-file (/proc/zoneinfo) and returns a slice of\n// structs containing the relevant info. More information available here:\n// https://www.kernel.org/doc/Documentation/sysctl/vm.txt\nfunc (fs FS) Zoneinfo() ([]Zoneinfo, error) {\n\tdata, err := os.ReadFile(fs.proc.Path(\"zoneinfo\"))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error reading zoneinfo %q: %w\", fs.proc.Path(\"zoneinfo\"), err)\n\t}\n\tzoneinfo, err := parseZoneinfo(data)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error parsing zoneinfo %q: %w\", fs.proc.Path(\"zoneinfo\"), err)\n\t}\n\treturn zoneinfo, nil\n}\n\nfunc parseZoneinfo(zoneinfoData []byte) ([]Zoneinfo, error) {\n\n\tzoneinfo := []Zoneinfo{}\n\n\tzoneinfoBlocks := bytes.Split(zoneinfoData, []byte(\"\\nNode\"))\n\tfor _, block := range zoneinfoBlocks {\n\t\tvar zoneinfoElement Zoneinfo\n\t\tlines := strings.Split(string(block), \"\\n\")\n\t\tfor _, line := range lines {\n\n\t\t\tif nodeZone := nodeZoneRE.FindStringSubmatch(line); nodeZone != nil {\n\t\t\t\tzoneinfoElement.Node = nodeZone[1]\n\t\t\t\tzoneinfoElement.Zone = nodeZone[2]\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif strings.HasPrefix(strings.TrimSpace(line), \"per-node stats\") {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tparts := strings.Fields(strings.TrimSpace(line))\n\t\t\tif len(parts) < 2 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tvp := util.NewValueParser(parts[1])\n\t\t\tswitch parts[0] {\n\t\t\tcase \"nr_free_pages\":\n\t\t\t\tzoneinfoElement.NrFreePages = vp.PInt64()\n\t\t\tcase \"min\":\n\t\t\t\tzoneinfoElement.Min = vp.PInt64()\n\t\t\tcase \"low\":\n\t\t\t\tzoneinfoElement.Low = vp.PInt64()\n\t\t\tcase \"high\":\n\t\t\t\tzoneinfoElement.High = vp.PInt64()\n\t\t\tcase \"scanned\":\n\t\t\t\tzoneinfoElement.Scanned = vp.PInt64()\n\t\t\tcase \"spanned\":\n\t\t\t\tzoneinfoElement.Spanned = vp.PInt64()\n\t\t\tcase \"present\":\n\t\t\t\tzoneinfoElement.Present = vp.PInt64()\n\t\t\tcase \"managed\":\n\t\t\t\tzoneinfoElement.Managed = vp.PInt64()\n\t\t\tcase \"nr_active_anon\":\n\t\t\t\tzoneinfoElement.NrActiveAnon = vp.PInt64()\n\t\t\tcase \"nr_inactive_anon\":\n\t\t\t\tzoneinfoElement.NrInactiveAnon = vp.PInt64()\n\t\t\tcase \"nr_isolated_anon\":\n\t\t\t\tzoneinfoElement.NrIsolatedAnon = vp.PInt64()\n\t\t\tcase \"nr_anon_pages\":\n\t\t\t\tzoneinfoElement.NrAnonPages = vp.PInt64()\n\t\t\tcase \"nr_anon_transparent_hugepages\":\n\t\t\t\tzoneinfoElement.NrAnonTransparentHugepages = vp.PInt64()\n\t\t\tcase \"nr_active_file\":\n\t\t\t\tzoneinfoElement.NrActiveFile = vp.PInt64()\n\t\t\tcase \"nr_inactive_file\":\n\t\t\t\tzoneinfoElement.NrInactiveFile = vp.PInt64()\n\t\t\tcase \"nr_isolated_file\":\n\t\t\t\tzoneinfoElement.NrIsolatedFile = vp.PInt64()\n\t\t\tcase \"nr_file_pages\":\n\t\t\t\tzoneinfoElement.NrFilePages = vp.PInt64()\n\t\t\tcase \"nr_slab_reclaimable\":\n\t\t\t\tzoneinfoElement.NrSlabReclaimable = vp.PInt64()\n\t\t\tcase \"nr_slab_unreclaimable\":\n\t\t\t\tzoneinfoElement.NrSlabUnreclaimable = vp.PInt64()\n\t\t\tcase \"nr_mlock_stack\":\n\t\t\t\tzoneinfoElement.NrMlockStack = vp.PInt64()\n\t\t\tcase \"nr_kernel_stack\":\n\t\t\t\tzoneinfoElement.NrKernelStack = vp.PInt64()\n\t\t\tcase \"nr_mapped\":\n\t\t\t\tzoneinfoElement.NrMapped = vp.PInt64()\n\t\t\tcase \"nr_dirty\":\n\t\t\t\tzoneinfoElement.NrDirty = vp.PInt64()\n\t\t\tcase \"nr_writeback\":\n\t\t\t\tzoneinfoElement.NrWriteback = vp.PInt64()\n\t\t\tcase \"nr_unevictable\":\n\t\t\t\tzoneinfoElement.NrUnevictable = vp.PInt64()\n\t\t\tcase \"nr_shmem\":\n\t\t\t\tzoneinfoElement.NrShmem = vp.PInt64()\n\t\t\tcase \"nr_dirtied\":\n\t\t\t\tzoneinfoElement.NrDirtied = vp.PInt64()\n\t\t\tcase \"nr_written\":\n\t\t\t\tzoneinfoElement.NrWritten = vp.PInt64()\n\t\t\tcase \"numa_hit\":\n\t\t\t\tzoneinfoElement.NumaHit = vp.PInt64()\n\t\t\tcase \"numa_miss\":\n\t\t\t\tzoneinfoElement.NumaMiss = vp.PInt64()\n\t\t\tcase \"numa_foreign\":\n\t\t\t\tzoneinfoElement.NumaForeign = vp.PInt64()\n\t\t\tcase \"numa_interleave\":\n\t\t\t\tzoneinfoElement.NumaInterleave = vp.PInt64()\n\t\t\tcase \"numa_local\":\n\t\t\t\tzoneinfoElement.NumaLocal = vp.PInt64()\n\t\t\tcase \"numa_other\":\n\t\t\t\tzoneinfoElement.NumaOther = vp.PInt64()\n\t\t\tcase \"protection:\":\n\t\t\t\tprotectionParts := strings.Split(line, \":\")\n\t\t\t\tprotectionValues := strings.Replace(protectionParts[1], \"(\", \"\", 1)\n\t\t\t\tprotectionValues = strings.Replace(protectionValues, \")\", \"\", 1)\n\t\t\t\tprotectionValues = strings.TrimSpace(protectionValues)\n\t\t\t\tprotectionStringMap := strings.Split(protectionValues, \", \")\n\t\t\t\tval, err := util.ParsePInt64s(protectionStringMap)\n\t\t\t\tif err == nil {\n\t\t\t\t\tzoneinfoElement.Protection = val\n\t\t\t\t}\n\t\t\t}\n\n\t\t}\n\n\t\tzoneinfo = append(zoneinfo, zoneinfoElement)\n\t}\n\treturn zoneinfo, nil\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/.gitignore",
"content": ".idea/*\n\n"
},
{
"path": "vendor/github.com/spf13/pflag/.travis.yml",
"content": "sudo: false\n\nlanguage: go\n\ngo:\n - 1.9.x\n - 1.10.x\n - 1.11.x\n - tip\n\nmatrix:\n allow_failures:\n - go: tip\n\ninstall:\n - go get golang.org/x/lint/golint\n - export PATH=$GOPATH/bin:$PATH\n - go install ./...\n\nscript:\n - verify/all.sh -v\n - go test ./...\n"
},
{
"path": "vendor/github.com/spf13/pflag/LICENSE",
"content": "Copyright (c) 2012 Alex Ogier. All rights reserved.\nCopyright (c) 2012 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/github.com/spf13/pflag/README.md",
"content": "[](https://travis-ci.org/spf13/pflag)\n[](https://goreportcard.com/report/github.com/spf13/pflag)\n[](https://godoc.org/github.com/spf13/pflag)\n\n## Description\n\npflag is a drop-in replacement for Go's flag package, implementing\nPOSIX/GNU-style --flags.\n\npflag is compatible with the [GNU extensions to the POSIX recommendations\nfor command-line options][1]. For a more precise description, see the\n\"Command-line flag syntax\" section below.\n\n[1]: http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html\n\npflag is available under the same style of BSD license as the Go language,\nwhich can be found in the LICENSE file.\n\n## Installation\n\npflag is available using the standard `go get` command.\n\nInstall by running:\n\n go get github.com/spf13/pflag\n\nRun tests by running:\n\n go test github.com/spf13/pflag\n\n## Usage\n\npflag is a drop-in replacement of Go's native flag package. If you import\npflag under the name \"flag\" then all code should continue to function\nwith no changes.\n\n``` go\nimport flag \"github.com/spf13/pflag\"\n```\n\nThere is one exception to this: if you directly instantiate the Flag struct\nthere is one more field \"Shorthand\" that you will need to set.\nMost code never instantiates this struct directly, and instead uses\nfunctions such as String(), BoolVar(), and Var(), and is therefore\nunaffected.\n\nDefine flags using flag.String(), Bool(), Int(), etc.\n\nThis declares an integer flag, -flagname, stored in the pointer ip, with type *int.\n\n``` go\nvar ip *int = flag.Int(\"flagname\", 1234, \"help message for flagname\")\n```\n\nIf you like, you can bind the flag to a variable using the Var() functions.\n\n``` go\nvar flagvar int\nfunc init() {\n flag.IntVar(&flagvar, \"flagname\", 1234, \"help message for flagname\")\n}\n```\n\nOr you can create custom flags that satisfy the Value interface (with\npointer receivers) and couple them to flag parsing by\n\n``` go\nflag.Var(&flagVal, \"name\", \"help message for flagname\")\n```\n\nFor such flags, the default value is just the initial value of the variable.\n\nAfter all flags are defined, call\n\n``` go\nflag.Parse()\n```\n\nto parse the command line into the defined flags.\n\nFlags may then be used directly. If you're using the flags themselves,\nthey are all pointers; if you bind to variables, they're values.\n\n``` go\nfmt.Println(\"ip has value \", *ip)\nfmt.Println(\"flagvar has value \", flagvar)\n```\n\nThere are helper functions available to get the value stored in a Flag if you have a FlagSet but find\nit difficult to keep up with all of the pointers in your code.\nIf you have a pflag.FlagSet with a flag called 'flagname' of type int you\ncan use GetInt() to get the int value. But notice that 'flagname' must exist\nand it must be an int. GetString(\"flagname\") will fail.\n\n``` go\ni, err := flagset.GetInt(\"flagname\")\n```\n\nAfter parsing, the arguments after the flag are available as the\nslice flag.Args() or individually as flag.Arg(i).\nThe arguments are indexed from 0 through flag.NArg()-1.\n\nThe pflag package also defines some new functions that are not in flag,\nthat give one-letter shorthands for flags. You can use these by appending\n'P' to the name of any function that defines a flag.\n\n``` go\nvar ip = flag.IntP(\"flagname\", \"f\", 1234, \"help message\")\nvar flagvar bool\nfunc init() {\n\tflag.BoolVarP(&flagvar, \"boolname\", \"b\", true, \"help message\")\n}\nflag.VarP(&flagVal, \"varname\", \"v\", \"help message\")\n```\n\nShorthand letters can be used with single dashes on the command line.\nBoolean shorthand flags can be combined with other shorthand flags.\n\nThe default set of command-line flags is controlled by\ntop-level functions. The FlagSet type allows one to define\nindependent sets of flags, such as to implement subcommands\nin a command-line interface. The methods of FlagSet are\nanalogous to the top-level functions for the command-line\nflag set.\n\n## Setting no option default values for flags\n\nAfter you create a flag it is possible to set the pflag.NoOptDefVal for\nthe given flag. Doing this changes the meaning of the flag slightly. If\na flag has a NoOptDefVal and the flag is set on the command line without\nan option the flag will be set to the NoOptDefVal. For example given:\n\n``` go\nvar ip = flag.IntP(\"flagname\", \"f\", 1234, \"help message\")\nflag.Lookup(\"flagname\").NoOptDefVal = \"4321\"\n```\n\nWould result in something like\n\n| Parsed Arguments | Resulting Value |\n| ------------- | ------------- |\n| --flagname=1357 | ip=1357 |\n| --flagname | ip=4321 |\n| [nothing] | ip=1234 |\n\n## Command line flag syntax\n\n```\n--flag // boolean flags, or flags with no option default values\n--flag x // only on flags without a default value\n--flag=x\n```\n\nUnlike the flag package, a single dash before an option means something\ndifferent than a double dash. Single dashes signify a series of shorthand\nletters for flags. All but the last shorthand letter must be boolean flags\nor a flag with a default value\n\n```\n// boolean or flags where the 'no option default value' is set\n-f\n-f=true\n-abc\nbut\n-b true is INVALID\n\n// non-boolean and flags without a 'no option default value'\n-n 1234\n-n=1234\n-n1234\n\n// mixed\n-abcs \"hello\"\n-absd=\"hello\"\n-abcs1234\n```\n\nFlag parsing stops after the terminator \"--\". Unlike the flag package,\nflags can be interspersed with arguments anywhere on the command line\nbefore this terminator.\n\nInteger flags accept 1234, 0664, 0x1234 and may be negative.\nBoolean flags (in their long form) accept 1, 0, t, f, true, false,\nTRUE, FALSE, True, False.\nDuration flags accept any input valid for time.ParseDuration.\n\n## Mutating or \"Normalizing\" Flag names\n\nIt is possible to set a custom flag name 'normalization function.' It allows flag names to be mutated both when created in the code and when used on the command line to some 'normalized' form. The 'normalized' form is used for comparison. Two examples of using the custom normalization func follow.\n\n**Example #1**: You want -, _, and . in flags to compare the same. aka --my-flag == --my_flag == --my.flag\n\n``` go\nfunc wordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {\n\tfrom := []string{\"-\", \"_\"}\n\tto := \".\"\n\tfor _, sep := range from {\n\t\tname = strings.Replace(name, sep, to, -1)\n\t}\n\treturn pflag.NormalizedName(name)\n}\n\nmyFlagSet.SetNormalizeFunc(wordSepNormalizeFunc)\n```\n\n**Example #2**: You want to alias two flags. aka --old-flag-name == --new-flag-name\n\n``` go\nfunc aliasNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {\n\tswitch name {\n\tcase \"old-flag-name\":\n\t\tname = \"new-flag-name\"\n\t\tbreak\n\t}\n\treturn pflag.NormalizedName(name)\n}\n\nmyFlagSet.SetNormalizeFunc(aliasNormalizeFunc)\n```\n\n## Deprecating a flag or its shorthand\nIt is possible to deprecate a flag, or just its shorthand. Deprecating a flag/shorthand hides it from help text and prints a usage message when the deprecated flag/shorthand is used.\n\n**Example #1**: You want to deprecate a flag named \"badflag\" as well as inform the users what flag they should use instead.\n```go\n// deprecate a flag by specifying its name and a usage message\nflags.MarkDeprecated(\"badflag\", \"please use --good-flag instead\")\n```\nThis hides \"badflag\" from help text, and prints `Flag --badflag has been deprecated, please use --good-flag instead` when \"badflag\" is used.\n\n**Example #2**: You want to keep a flag name \"noshorthandflag\" but deprecate its shortname \"n\".\n```go\n// deprecate a flag shorthand by specifying its flag name and a usage message\nflags.MarkShorthandDeprecated(\"noshorthandflag\", \"please use --noshorthandflag only\")\n```\nThis hides the shortname \"n\" from help text, and prints `Flag shorthand -n has been deprecated, please use --noshorthandflag only` when the shorthand \"n\" is used.\n\nNote that usage message is essential here, and it should not be empty.\n\n## Hidden flags\nIt is possible to mark a flag as hidden, meaning it will still function as normal, however will not show up in usage/help text.\n\n**Example**: You have a flag named \"secretFlag\" that you need for internal use only and don't want it showing up in help text, or for its usage text to be available.\n```go\n// hide a flag by specifying its name\nflags.MarkHidden(\"secretFlag\")\n```\n\n## Disable sorting of flags\n`pflag` allows you to disable sorting of flags for help and usage message.\n\n**Example**:\n```go\nflags.BoolP(\"verbose\", \"v\", false, \"verbose output\")\nflags.String(\"coolflag\", \"yeaah\", \"it's really cool flag\")\nflags.Int(\"usefulflag\", 777, \"sometimes it's very useful\")\nflags.SortFlags = false\nflags.PrintDefaults()\n```\n**Output**:\n```\n -v, --verbose verbose output\n --coolflag string it's really cool flag (default \"yeaah\")\n --usefulflag int sometimes it's very useful (default 777)\n```\n\n\n## Supporting Go flags when using pflag\nIn order to support flags defined using Go's `flag` package, they must be added to the `pflag` flagset. This is usually necessary\nto support flags defined by third-party dependencies (e.g. `golang/glog`).\n\n**Example**: You want to add the Go flags to the `CommandLine` flagset\n```go\nimport (\n\tgoflag \"flag\"\n\tflag \"github.com/spf13/pflag\"\n)\n\nvar ip *int = flag.Int(\"flagname\", 1234, \"help message for flagname\")\n\nfunc main() {\n\tflag.CommandLine.AddGoFlagSet(goflag.CommandLine)\n\tflag.Parse()\n}\n```\n\n## More info\n\nYou can see the full reference documentation of the pflag package\n[at godoc.org][3], or through go's standard documentation system by\nrunning `godoc -http=:6060` and browsing to\n[http://localhost:6060/pkg/github.com/spf13/pflag][2] after\ninstallation.\n\n[2]: http://localhost:6060/pkg/github.com/spf13/pflag\n[3]: http://godoc.org/github.com/spf13/pflag\n"
},
{
"path": "vendor/github.com/spf13/pflag/bool.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// optional interface to indicate boolean flags that can be\n// supplied without \"=value\" text\ntype boolFlag interface {\n\tValue\n\tIsBoolFlag() bool\n}\n\n// -- bool Value\ntype boolValue bool\n\nfunc newBoolValue(val bool, p *bool) *boolValue {\n\t*p = val\n\treturn (*boolValue)(p)\n}\n\nfunc (b *boolValue) Set(s string) error {\n\tv, err := strconv.ParseBool(s)\n\t*b = boolValue(v)\n\treturn err\n}\n\nfunc (b *boolValue) Type() string {\n\treturn \"bool\"\n}\n\nfunc (b *boolValue) String() string { return strconv.FormatBool(bool(*b)) }\n\nfunc (b *boolValue) IsBoolFlag() bool { return true }\n\nfunc boolConv(sval string) (interface{}, error) {\n\treturn strconv.ParseBool(sval)\n}\n\n// GetBool return the bool value of a flag with the given name\nfunc (f *FlagSet) GetBool(name string) (bool, error) {\n\tval, err := f.getFlagType(name, \"bool\", boolConv)\n\tif err != nil {\n\t\treturn false, err\n\t}\n\treturn val.(bool), nil\n}\n\n// BoolVar defines a bool flag with specified name, default value, and usage string.\n// The argument p points to a bool variable in which to store the value of the flag.\nfunc (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {\n\tf.BoolVarP(p, name, \"\", value, usage)\n}\n\n// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BoolVarP(p *bool, name, shorthand string, value bool, usage string) {\n\tflag := f.VarPF(newBoolValue(value, p), name, shorthand, usage)\n\tflag.NoOptDefVal = \"true\"\n}\n\n// BoolVar defines a bool flag with specified name, default value, and usage string.\n// The argument p points to a bool variable in which to store the value of the flag.\nfunc BoolVar(p *bool, name string, value bool, usage string) {\n\tBoolVarP(p, name, \"\", value, usage)\n}\n\n// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.\nfunc BoolVarP(p *bool, name, shorthand string, value bool, usage string) {\n\tflag := CommandLine.VarPF(newBoolValue(value, p), name, shorthand, usage)\n\tflag.NoOptDefVal = \"true\"\n}\n\n// Bool defines a bool flag with specified name, default value, and usage string.\n// The return value is the address of a bool variable that stores the value of the flag.\nfunc (f *FlagSet) Bool(name string, value bool, usage string) *bool {\n\treturn f.BoolP(name, \"\", value, usage)\n}\n\n// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BoolP(name, shorthand string, value bool, usage string) *bool {\n\tp := new(bool)\n\tf.BoolVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Bool defines a bool flag with specified name, default value, and usage string.\n// The return value is the address of a bool variable that stores the value of the flag.\nfunc Bool(name string, value bool, usage string) *bool {\n\treturn BoolP(name, \"\", value, usage)\n}\n\n// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.\nfunc BoolP(name, shorthand string, value bool, usage string) *bool {\n\tb := CommandLine.BoolP(name, shorthand, value, usage)\n\treturn b\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/bool_slice.go",
"content": "package pflag\n\nimport (\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- boolSlice Value\ntype boolSliceValue struct {\n\tvalue *[]bool\n\tchanged bool\n}\n\nfunc newBoolSliceValue(val []bool, p *[]bool) *boolSliceValue {\n\tbsv := new(boolSliceValue)\n\tbsv.value = p\n\t*bsv.value = val\n\treturn bsv\n}\n\n// Set converts, and assigns, the comma-separated boolean argument string representation as the []bool value of this flag.\n// If Set is called on a flag that already has a []bool assigned, the newly converted values will be appended.\nfunc (s *boolSliceValue) Set(val string) error {\n\n\t// remove all quote characters\n\trmQuote := strings.NewReplacer(`\"`, \"\", `'`, \"\", \"`\", \"\")\n\n\t// read flag arguments with CSV parser\n\tboolStrSlice, err := readAsCSV(rmQuote.Replace(val))\n\tif err != nil && err != io.EOF {\n\t\treturn err\n\t}\n\n\t// parse boolean values into slice\n\tout := make([]bool, 0, len(boolStrSlice))\n\tfor _, boolStr := range boolStrSlice {\n\t\tb, err := strconv.ParseBool(strings.TrimSpace(boolStr))\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tout = append(out, b)\n\t}\n\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\n\ts.changed = true\n\n\treturn nil\n}\n\n// Type returns a string that uniquely represents this flag's type.\nfunc (s *boolSliceValue) Type() string {\n\treturn \"boolSlice\"\n}\n\n// String defines a \"native\" format for this boolean slice flag value.\nfunc (s *boolSliceValue) String() string {\n\n\tboolStrSlice := make([]string, len(*s.value))\n\tfor i, b := range *s.value {\n\t\tboolStrSlice[i] = strconv.FormatBool(b)\n\t}\n\n\tout, _ := writeAsCSV(boolStrSlice)\n\n\treturn \"[\" + out + \"]\"\n}\n\nfunc (s *boolSliceValue) fromString(val string) (bool, error) {\n\treturn strconv.ParseBool(val)\n}\n\nfunc (s *boolSliceValue) toString(val bool) string {\n\treturn strconv.FormatBool(val)\n}\n\nfunc (s *boolSliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *boolSliceValue) Replace(val []string) error {\n\tout := make([]bool, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *boolSliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc boolSliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []bool{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]bool, len(ss))\n\tfor i, t := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.ParseBool(t)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\treturn out, nil\n}\n\n// GetBoolSlice returns the []bool value of a flag with the given name.\nfunc (f *FlagSet) GetBoolSlice(name string) ([]bool, error) {\n\tval, err := f.getFlagType(name, \"boolSlice\", boolSliceConv)\n\tif err != nil {\n\t\treturn []bool{}, err\n\t}\n\treturn val.([]bool), nil\n}\n\n// BoolSliceVar defines a boolSlice flag with specified name, default value, and usage string.\n// The argument p points to a []bool variable in which to store the value of the flag.\nfunc (f *FlagSet) BoolSliceVar(p *[]bool, name string, value []bool, usage string) {\n\tf.VarP(newBoolSliceValue(value, p), name, \"\", usage)\n}\n\n// BoolSliceVarP is like BoolSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BoolSliceVarP(p *[]bool, name, shorthand string, value []bool, usage string) {\n\tf.VarP(newBoolSliceValue(value, p), name, shorthand, usage)\n}\n\n// BoolSliceVar defines a []bool flag with specified name, default value, and usage string.\n// The argument p points to a []bool variable in which to store the value of the flag.\nfunc BoolSliceVar(p *[]bool, name string, value []bool, usage string) {\n\tCommandLine.VarP(newBoolSliceValue(value, p), name, \"\", usage)\n}\n\n// BoolSliceVarP is like BoolSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc BoolSliceVarP(p *[]bool, name, shorthand string, value []bool, usage string) {\n\tCommandLine.VarP(newBoolSliceValue(value, p), name, shorthand, usage)\n}\n\n// BoolSlice defines a []bool flag with specified name, default value, and usage string.\n// The return value is the address of a []bool variable that stores the value of the flag.\nfunc (f *FlagSet) BoolSlice(name string, value []bool, usage string) *[]bool {\n\tp := []bool{}\n\tf.BoolSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// BoolSliceP is like BoolSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BoolSliceP(name, shorthand string, value []bool, usage string) *[]bool {\n\tp := []bool{}\n\tf.BoolSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// BoolSlice defines a []bool flag with specified name, default value, and usage string.\n// The return value is the address of a []bool variable that stores the value of the flag.\nfunc BoolSlice(name string, value []bool, usage string) *[]bool {\n\treturn CommandLine.BoolSliceP(name, \"\", value, usage)\n}\n\n// BoolSliceP is like BoolSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc BoolSliceP(name, shorthand string, value []bool, usage string) *[]bool {\n\treturn CommandLine.BoolSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/bytes.go",
"content": "package pflag\n\nimport (\n\t\"encoding/base64\"\n\t\"encoding/hex\"\n\t\"fmt\"\n\t\"strings\"\n)\n\n// BytesHex adapts []byte for use as a flag. Value of flag is HEX encoded\ntype bytesHexValue []byte\n\n// String implements pflag.Value.String.\nfunc (bytesHex bytesHexValue) String() string {\n\treturn fmt.Sprintf(\"%X\", []byte(bytesHex))\n}\n\n// Set implements pflag.Value.Set.\nfunc (bytesHex *bytesHexValue) Set(value string) error {\n\tbin, err := hex.DecodeString(strings.TrimSpace(value))\n\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t*bytesHex = bin\n\n\treturn nil\n}\n\n// Type implements pflag.Value.Type.\nfunc (*bytesHexValue) Type() string {\n\treturn \"bytesHex\"\n}\n\nfunc newBytesHexValue(val []byte, p *[]byte) *bytesHexValue {\n\t*p = val\n\treturn (*bytesHexValue)(p)\n}\n\nfunc bytesHexConv(sval string) (interface{}, error) {\n\n\tbin, err := hex.DecodeString(sval)\n\n\tif err == nil {\n\t\treturn bin, nil\n\t}\n\n\treturn nil, fmt.Errorf(\"invalid string being converted to Bytes: %s %s\", sval, err)\n}\n\n// GetBytesHex return the []byte value of a flag with the given name\nfunc (f *FlagSet) GetBytesHex(name string) ([]byte, error) {\n\tval, err := f.getFlagType(name, \"bytesHex\", bytesHexConv)\n\n\tif err != nil {\n\t\treturn []byte{}, err\n\t}\n\n\treturn val.([]byte), nil\n}\n\n// BytesHexVar defines an []byte flag with specified name, default value, and usage string.\n// The argument p points to an []byte variable in which to store the value of the flag.\nfunc (f *FlagSet) BytesHexVar(p *[]byte, name string, value []byte, usage string) {\n\tf.VarP(newBytesHexValue(value, p), name, \"\", usage)\n}\n\n// BytesHexVarP is like BytesHexVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BytesHexVarP(p *[]byte, name, shorthand string, value []byte, usage string) {\n\tf.VarP(newBytesHexValue(value, p), name, shorthand, usage)\n}\n\n// BytesHexVar defines an []byte flag with specified name, default value, and usage string.\n// The argument p points to an []byte variable in which to store the value of the flag.\nfunc BytesHexVar(p *[]byte, name string, value []byte, usage string) {\n\tCommandLine.VarP(newBytesHexValue(value, p), name, \"\", usage)\n}\n\n// BytesHexVarP is like BytesHexVar, but accepts a shorthand letter that can be used after a single dash.\nfunc BytesHexVarP(p *[]byte, name, shorthand string, value []byte, usage string) {\n\tCommandLine.VarP(newBytesHexValue(value, p), name, shorthand, usage)\n}\n\n// BytesHex defines an []byte flag with specified name, default value, and usage string.\n// The return value is the address of an []byte variable that stores the value of the flag.\nfunc (f *FlagSet) BytesHex(name string, value []byte, usage string) *[]byte {\n\tp := new([]byte)\n\tf.BytesHexVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// BytesHexP is like BytesHex, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BytesHexP(name, shorthand string, value []byte, usage string) *[]byte {\n\tp := new([]byte)\n\tf.BytesHexVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// BytesHex defines an []byte flag with specified name, default value, and usage string.\n// The return value is the address of an []byte variable that stores the value of the flag.\nfunc BytesHex(name string, value []byte, usage string) *[]byte {\n\treturn CommandLine.BytesHexP(name, \"\", value, usage)\n}\n\n// BytesHexP is like BytesHex, but accepts a shorthand letter that can be used after a single dash.\nfunc BytesHexP(name, shorthand string, value []byte, usage string) *[]byte {\n\treturn CommandLine.BytesHexP(name, shorthand, value, usage)\n}\n\n// BytesBase64 adapts []byte for use as a flag. Value of flag is Base64 encoded\ntype bytesBase64Value []byte\n\n// String implements pflag.Value.String.\nfunc (bytesBase64 bytesBase64Value) String() string {\n\treturn base64.StdEncoding.EncodeToString([]byte(bytesBase64))\n}\n\n// Set implements pflag.Value.Set.\nfunc (bytesBase64 *bytesBase64Value) Set(value string) error {\n\tbin, err := base64.StdEncoding.DecodeString(strings.TrimSpace(value))\n\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t*bytesBase64 = bin\n\n\treturn nil\n}\n\n// Type implements pflag.Value.Type.\nfunc (*bytesBase64Value) Type() string {\n\treturn \"bytesBase64\"\n}\n\nfunc newBytesBase64Value(val []byte, p *[]byte) *bytesBase64Value {\n\t*p = val\n\treturn (*bytesBase64Value)(p)\n}\n\nfunc bytesBase64ValueConv(sval string) (interface{}, error) {\n\n\tbin, err := base64.StdEncoding.DecodeString(sval)\n\tif err == nil {\n\t\treturn bin, nil\n\t}\n\n\treturn nil, fmt.Errorf(\"invalid string being converted to Bytes: %s %s\", sval, err)\n}\n\n// GetBytesBase64 return the []byte value of a flag with the given name\nfunc (f *FlagSet) GetBytesBase64(name string) ([]byte, error) {\n\tval, err := f.getFlagType(name, \"bytesBase64\", bytesBase64ValueConv)\n\n\tif err != nil {\n\t\treturn []byte{}, err\n\t}\n\n\treturn val.([]byte), nil\n}\n\n// BytesBase64Var defines an []byte flag with specified name, default value, and usage string.\n// The argument p points to an []byte variable in which to store the value of the flag.\nfunc (f *FlagSet) BytesBase64Var(p *[]byte, name string, value []byte, usage string) {\n\tf.VarP(newBytesBase64Value(value, p), name, \"\", usage)\n}\n\n// BytesBase64VarP is like BytesBase64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BytesBase64VarP(p *[]byte, name, shorthand string, value []byte, usage string) {\n\tf.VarP(newBytesBase64Value(value, p), name, shorthand, usage)\n}\n\n// BytesBase64Var defines an []byte flag with specified name, default value, and usage string.\n// The argument p points to an []byte variable in which to store the value of the flag.\nfunc BytesBase64Var(p *[]byte, name string, value []byte, usage string) {\n\tCommandLine.VarP(newBytesBase64Value(value, p), name, \"\", usage)\n}\n\n// BytesBase64VarP is like BytesBase64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc BytesBase64VarP(p *[]byte, name, shorthand string, value []byte, usage string) {\n\tCommandLine.VarP(newBytesBase64Value(value, p), name, shorthand, usage)\n}\n\n// BytesBase64 defines an []byte flag with specified name, default value, and usage string.\n// The return value is the address of an []byte variable that stores the value of the flag.\nfunc (f *FlagSet) BytesBase64(name string, value []byte, usage string) *[]byte {\n\tp := new([]byte)\n\tf.BytesBase64VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// BytesBase64P is like BytesBase64, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) BytesBase64P(name, shorthand string, value []byte, usage string) *[]byte {\n\tp := new([]byte)\n\tf.BytesBase64VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// BytesBase64 defines an []byte flag with specified name, default value, and usage string.\n// The return value is the address of an []byte variable that stores the value of the flag.\nfunc BytesBase64(name string, value []byte, usage string) *[]byte {\n\treturn CommandLine.BytesBase64P(name, \"\", value, usage)\n}\n\n// BytesBase64P is like BytesBase64, but accepts a shorthand letter that can be used after a single dash.\nfunc BytesBase64P(name, shorthand string, value []byte, usage string) *[]byte {\n\treturn CommandLine.BytesBase64P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/count.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- count Value\ntype countValue int\n\nfunc newCountValue(val int, p *int) *countValue {\n\t*p = val\n\treturn (*countValue)(p)\n}\n\nfunc (i *countValue) Set(s string) error {\n\t// \"+1\" means that no specific value was passed, so increment\n\tif s == \"+1\" {\n\t\t*i = countValue(*i + 1)\n\t\treturn nil\n\t}\n\tv, err := strconv.ParseInt(s, 0, 0)\n\t*i = countValue(v)\n\treturn err\n}\n\nfunc (i *countValue) Type() string {\n\treturn \"count\"\n}\n\nfunc (i *countValue) String() string { return strconv.Itoa(int(*i)) }\n\nfunc countConv(sval string) (interface{}, error) {\n\ti, err := strconv.Atoi(sval)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn i, nil\n}\n\n// GetCount return the int value of a flag with the given name\nfunc (f *FlagSet) GetCount(name string) (int, error) {\n\tval, err := f.getFlagType(name, \"count\", countConv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int), nil\n}\n\n// CountVar defines a count flag with specified name, default value, and usage string.\n// The argument p points to an int variable in which to store the value of the flag.\n// A count flag will add 1 to its value every time it is found on the command line\nfunc (f *FlagSet) CountVar(p *int, name string, usage string) {\n\tf.CountVarP(p, name, \"\", usage)\n}\n\n// CountVarP is like CountVar only take a shorthand for the flag name.\nfunc (f *FlagSet) CountVarP(p *int, name, shorthand string, usage string) {\n\tflag := f.VarPF(newCountValue(0, p), name, shorthand, usage)\n\tflag.NoOptDefVal = \"+1\"\n}\n\n// CountVar like CountVar only the flag is placed on the CommandLine instead of a given flag set\nfunc CountVar(p *int, name string, usage string) {\n\tCommandLine.CountVar(p, name, usage)\n}\n\n// CountVarP is like CountVar only take a shorthand for the flag name.\nfunc CountVarP(p *int, name, shorthand string, usage string) {\n\tCommandLine.CountVarP(p, name, shorthand, usage)\n}\n\n// Count defines a count flag with specified name, default value, and usage string.\n// The return value is the address of an int variable that stores the value of the flag.\n// A count flag will add 1 to its value every time it is found on the command line\nfunc (f *FlagSet) Count(name string, usage string) *int {\n\tp := new(int)\n\tf.CountVarP(p, name, \"\", usage)\n\treturn p\n}\n\n// CountP is like Count only takes a shorthand for the flag name.\nfunc (f *FlagSet) CountP(name, shorthand string, usage string) *int {\n\tp := new(int)\n\tf.CountVarP(p, name, shorthand, usage)\n\treturn p\n}\n\n// Count defines a count flag with specified name, default value, and usage string.\n// The return value is the address of an int variable that stores the value of the flag.\n// A count flag will add 1 to its value evey time it is found on the command line\nfunc Count(name string, usage string) *int {\n\treturn CommandLine.CountP(name, \"\", usage)\n}\n\n// CountP is like Count only takes a shorthand for the flag name.\nfunc CountP(name, shorthand string, usage string) *int {\n\treturn CommandLine.CountP(name, shorthand, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/duration.go",
"content": "package pflag\n\nimport (\n\t\"time\"\n)\n\n// -- time.Duration Value\ntype durationValue time.Duration\n\nfunc newDurationValue(val time.Duration, p *time.Duration) *durationValue {\n\t*p = val\n\treturn (*durationValue)(p)\n}\n\nfunc (d *durationValue) Set(s string) error {\n\tv, err := time.ParseDuration(s)\n\t*d = durationValue(v)\n\treturn err\n}\n\nfunc (d *durationValue) Type() string {\n\treturn \"duration\"\n}\n\nfunc (d *durationValue) String() string { return (*time.Duration)(d).String() }\n\nfunc durationConv(sval string) (interface{}, error) {\n\treturn time.ParseDuration(sval)\n}\n\n// GetDuration return the duration value of a flag with the given name\nfunc (f *FlagSet) GetDuration(name string) (time.Duration, error) {\n\tval, err := f.getFlagType(name, \"duration\", durationConv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(time.Duration), nil\n}\n\n// DurationVar defines a time.Duration flag with specified name, default value, and usage string.\n// The argument p points to a time.Duration variable in which to store the value of the flag.\nfunc (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) {\n\tf.VarP(newDurationValue(value, p), name, \"\", usage)\n}\n\n// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {\n\tf.VarP(newDurationValue(value, p), name, shorthand, usage)\n}\n\n// DurationVar defines a time.Duration flag with specified name, default value, and usage string.\n// The argument p points to a time.Duration variable in which to store the value of the flag.\nfunc DurationVar(p *time.Duration, name string, value time.Duration, usage string) {\n\tCommandLine.VarP(newDurationValue(value, p), name, \"\", usage)\n}\n\n// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.\nfunc DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {\n\tCommandLine.VarP(newDurationValue(value, p), name, shorthand, usage)\n}\n\n// Duration defines a time.Duration flag with specified name, default value, and usage string.\n// The return value is the address of a time.Duration variable that stores the value of the flag.\nfunc (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration {\n\tp := new(time.Duration)\n\tf.DurationVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {\n\tp := new(time.Duration)\n\tf.DurationVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Duration defines a time.Duration flag with specified name, default value, and usage string.\n// The return value is the address of a time.Duration variable that stores the value of the flag.\nfunc Duration(name string, value time.Duration, usage string) *time.Duration {\n\treturn CommandLine.DurationP(name, \"\", value, usage)\n}\n\n// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.\nfunc DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {\n\treturn CommandLine.DurationP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/duration_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\t\"time\"\n)\n\n// -- durationSlice Value\ntype durationSliceValue struct {\n\tvalue *[]time.Duration\n\tchanged bool\n}\n\nfunc newDurationSliceValue(val []time.Duration, p *[]time.Duration) *durationSliceValue {\n\tdsv := new(durationSliceValue)\n\tdsv.value = p\n\t*dsv.value = val\n\treturn dsv\n}\n\nfunc (s *durationSliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]time.Duration, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = time.ParseDuration(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *durationSliceValue) Type() string {\n\treturn \"durationSlice\"\n}\n\nfunc (s *durationSliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%s\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *durationSliceValue) fromString(val string) (time.Duration, error) {\n\treturn time.ParseDuration(val)\n}\n\nfunc (s *durationSliceValue) toString(val time.Duration) string {\n\treturn fmt.Sprintf(\"%s\", val)\n}\n\nfunc (s *durationSliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *durationSliceValue) Replace(val []string) error {\n\tout := make([]time.Duration, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *durationSliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc durationSliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []time.Duration{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]time.Duration, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = time.ParseDuration(d)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t}\n\treturn out, nil\n}\n\n// GetDurationSlice returns the []time.Duration value of a flag with the given name\nfunc (f *FlagSet) GetDurationSlice(name string) ([]time.Duration, error) {\n\tval, err := f.getFlagType(name, \"durationSlice\", durationSliceConv)\n\tif err != nil {\n\t\treturn []time.Duration{}, err\n\t}\n\treturn val.([]time.Duration), nil\n}\n\n// DurationSliceVar defines a durationSlice flag with specified name, default value, and usage string.\n// The argument p points to a []time.Duration variable in which to store the value of the flag.\nfunc (f *FlagSet) DurationSliceVar(p *[]time.Duration, name string, value []time.Duration, usage string) {\n\tf.VarP(newDurationSliceValue(value, p), name, \"\", usage)\n}\n\n// DurationSliceVarP is like DurationSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) DurationSliceVarP(p *[]time.Duration, name, shorthand string, value []time.Duration, usage string) {\n\tf.VarP(newDurationSliceValue(value, p), name, shorthand, usage)\n}\n\n// DurationSliceVar defines a duration[] flag with specified name, default value, and usage string.\n// The argument p points to a duration[] variable in which to store the value of the flag.\nfunc DurationSliceVar(p *[]time.Duration, name string, value []time.Duration, usage string) {\n\tCommandLine.VarP(newDurationSliceValue(value, p), name, \"\", usage)\n}\n\n// DurationSliceVarP is like DurationSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc DurationSliceVarP(p *[]time.Duration, name, shorthand string, value []time.Duration, usage string) {\n\tCommandLine.VarP(newDurationSliceValue(value, p), name, shorthand, usage)\n}\n\n// DurationSlice defines a []time.Duration flag with specified name, default value, and usage string.\n// The return value is the address of a []time.Duration variable that stores the value of the flag.\nfunc (f *FlagSet) DurationSlice(name string, value []time.Duration, usage string) *[]time.Duration {\n\tp := []time.Duration{}\n\tf.DurationSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// DurationSliceP is like DurationSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) DurationSliceP(name, shorthand string, value []time.Duration, usage string) *[]time.Duration {\n\tp := []time.Duration{}\n\tf.DurationSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// DurationSlice defines a []time.Duration flag with specified name, default value, and usage string.\n// The return value is the address of a []time.Duration variable that stores the value of the flag.\nfunc DurationSlice(name string, value []time.Duration, usage string) *[]time.Duration {\n\treturn CommandLine.DurationSliceP(name, \"\", value, usage)\n}\n\n// DurationSliceP is like DurationSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc DurationSliceP(name, shorthand string, value []time.Duration, usage string) *[]time.Duration {\n\treturn CommandLine.DurationSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/flag.go",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n/*\nPackage pflag is a drop-in replacement for Go's flag package, implementing\nPOSIX/GNU-style --flags.\n\npflag is compatible with the GNU extensions to the POSIX recommendations\nfor command-line options. See\nhttp://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html\n\nUsage:\n\npflag is a drop-in replacement of Go's native flag package. If you import\npflag under the name \"flag\" then all code should continue to function\nwith no changes.\n\n\timport flag \"github.com/spf13/pflag\"\n\nThere is one exception to this: if you directly instantiate the Flag struct\nthere is one more field \"Shorthand\" that you will need to set.\nMost code never instantiates this struct directly, and instead uses\nfunctions such as String(), BoolVar(), and Var(), and is therefore\nunaffected.\n\nDefine flags using flag.String(), Bool(), Int(), etc.\n\nThis declares an integer flag, -flagname, stored in the pointer ip, with type *int.\n\tvar ip = flag.Int(\"flagname\", 1234, \"help message for flagname\")\nIf you like, you can bind the flag to a variable using the Var() functions.\n\tvar flagvar int\n\tfunc init() {\n\t\tflag.IntVar(&flagvar, \"flagname\", 1234, \"help message for flagname\")\n\t}\nOr you can create custom flags that satisfy the Value interface (with\npointer receivers) and couple them to flag parsing by\n\tflag.Var(&flagVal, \"name\", \"help message for flagname\")\nFor such flags, the default value is just the initial value of the variable.\n\nAfter all flags are defined, call\n\tflag.Parse()\nto parse the command line into the defined flags.\n\nFlags may then be used directly. If you're using the flags themselves,\nthey are all pointers; if you bind to variables, they're values.\n\tfmt.Println(\"ip has value \", *ip)\n\tfmt.Println(\"flagvar has value \", flagvar)\n\nAfter parsing, the arguments after the flag are available as the\nslice flag.Args() or individually as flag.Arg(i).\nThe arguments are indexed from 0 through flag.NArg()-1.\n\nThe pflag package also defines some new functions that are not in flag,\nthat give one-letter shorthands for flags. You can use these by appending\n'P' to the name of any function that defines a flag.\n\tvar ip = flag.IntP(\"flagname\", \"f\", 1234, \"help message\")\n\tvar flagvar bool\n\tfunc init() {\n\t\tflag.BoolVarP(&flagvar, \"boolname\", \"b\", true, \"help message\")\n\t}\n\tflag.VarP(&flagval, \"varname\", \"v\", \"help message\")\nShorthand letters can be used with single dashes on the command line.\nBoolean shorthand flags can be combined with other shorthand flags.\n\nCommand line flag syntax:\n\t--flag // boolean flags only\n\t--flag=x\n\nUnlike the flag package, a single dash before an option means something\ndifferent than a double dash. Single dashes signify a series of shorthand\nletters for flags. All but the last shorthand letter must be boolean flags.\n\t// boolean flags\n\t-f\n\t-abc\n\t// non-boolean flags\n\t-n 1234\n\t-Ifile\n\t// mixed\n\t-abcs \"hello\"\n\t-abcn1234\n\nFlag parsing stops after the terminator \"--\". Unlike the flag package,\nflags can be interspersed with arguments anywhere on the command line\nbefore this terminator.\n\nInteger flags accept 1234, 0664, 0x1234 and may be negative.\nBoolean flags (in their long form) accept 1, 0, t, f, true, false,\nTRUE, FALSE, True, False.\nDuration flags accept any input valid for time.ParseDuration.\n\nThe default set of command-line flags is controlled by\ntop-level functions. The FlagSet type allows one to define\nindependent sets of flags, such as to implement subcommands\nin a command-line interface. The methods of FlagSet are\nanalogous to the top-level functions for the command-line\nflag set.\n*/\npackage pflag\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\tgoflag \"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"sort\"\n\t\"strings\"\n)\n\n// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined.\nvar ErrHelp = errors.New(\"pflag: help requested\")\n\n// ErrorHandling defines how to handle flag parsing errors.\ntype ErrorHandling int\n\nconst (\n\t// ContinueOnError will return an err from Parse() if an error is found\n\tContinueOnError ErrorHandling = iota\n\t// ExitOnError will call os.Exit(2) if an error is found when parsing\n\tExitOnError\n\t// PanicOnError will panic() if an error is found when parsing flags\n\tPanicOnError\n)\n\n// ParseErrorsWhitelist defines the parsing errors that can be ignored\ntype ParseErrorsWhitelist struct {\n\t// UnknownFlags will ignore unknown flags errors and continue parsing rest of the flags\n\tUnknownFlags bool\n}\n\n// NormalizedName is a flag name that has been normalized according to rules\n// for the FlagSet (e.g. making '-' and '_' equivalent).\ntype NormalizedName string\n\n// A FlagSet represents a set of defined flags.\ntype FlagSet struct {\n\t// Usage is the function called when an error occurs while parsing flags.\n\t// The field is a function (not a method) that may be changed to point to\n\t// a custom error handler.\n\tUsage func()\n\n\t// SortFlags is used to indicate, if user wants to have sorted flags in\n\t// help/usage messages.\n\tSortFlags bool\n\n\t// ParseErrorsWhitelist is used to configure a whitelist of errors\n\tParseErrorsWhitelist ParseErrorsWhitelist\n\n\tname string\n\tparsed bool\n\tactual map[NormalizedName]*Flag\n\torderedActual []*Flag\n\tsortedActual []*Flag\n\tformal map[NormalizedName]*Flag\n\torderedFormal []*Flag\n\tsortedFormal []*Flag\n\tshorthands map[byte]*Flag\n\targs []string // arguments after flags\n\targsLenAtDash int // len(args) when a '--' was located when parsing, or -1 if no --\n\terrorHandling ErrorHandling\n\toutput io.Writer // nil means stderr; use out() accessor\n\tinterspersed bool // allow interspersed option/non-option args\n\tnormalizeNameFunc func(f *FlagSet, name string) NormalizedName\n\n\taddedGoFlagSets []*goflag.FlagSet\n}\n\n// A Flag represents the state of a flag.\ntype Flag struct {\n\tName string // name as it appears on command line\n\tShorthand string // one-letter abbreviated flag\n\tUsage string // help message\n\tValue Value // value as set\n\tDefValue string // default value (as text); for usage message\n\tChanged bool // If the user set the value (or if left to default)\n\tNoOptDefVal string // default value (as text); if the flag is on the command line without any options\n\tDeprecated string // If this flag is deprecated, this string is the new or now thing to use\n\tHidden bool // used by cobra.Command to allow flags to be hidden from help/usage text\n\tShorthandDeprecated string // If the shorthand of this flag is deprecated, this string is the new or now thing to use\n\tAnnotations map[string][]string // used by cobra.Command bash autocomple code\n}\n\n// Value is the interface to the dynamic value stored in a flag.\n// (The default value is represented as a string.)\ntype Value interface {\n\tString() string\n\tSet(string) error\n\tType() string\n}\n\n// SliceValue is a secondary interface to all flags which hold a list\n// of values. This allows full control over the value of list flags,\n// and avoids complicated marshalling and unmarshalling to csv.\ntype SliceValue interface {\n\t// Append adds the specified value to the end of the flag value list.\n\tAppend(string) error\n\t// Replace will fully overwrite any data currently in the flag value list.\n\tReplace([]string) error\n\t// GetSlice returns the flag value list as an array of strings.\n\tGetSlice() []string\n}\n\n// sortFlags returns the flags as a slice in lexicographical sorted order.\nfunc sortFlags(flags map[NormalizedName]*Flag) []*Flag {\n\tlist := make(sort.StringSlice, len(flags))\n\ti := 0\n\tfor k := range flags {\n\t\tlist[i] = string(k)\n\t\ti++\n\t}\n\tlist.Sort()\n\tresult := make([]*Flag, len(list))\n\tfor i, name := range list {\n\t\tresult[i] = flags[NormalizedName(name)]\n\t}\n\treturn result\n}\n\n// SetNormalizeFunc allows you to add a function which can translate flag names.\n// Flags added to the FlagSet will be translated and then when anything tries to\n// look up the flag that will also be translated. So it would be possible to create\n// a flag named \"getURL\" and have it translated to \"geturl\". A user could then pass\n// \"--getUrl\" which may also be translated to \"geturl\" and everything will work.\nfunc (f *FlagSet) SetNormalizeFunc(n func(f *FlagSet, name string) NormalizedName) {\n\tf.normalizeNameFunc = n\n\tf.sortedFormal = f.sortedFormal[:0]\n\tfor fname, flag := range f.formal {\n\t\tnname := f.normalizeFlagName(flag.Name)\n\t\tif fname == nname {\n\t\t\tcontinue\n\t\t}\n\t\tflag.Name = string(nname)\n\t\tdelete(f.formal, fname)\n\t\tf.formal[nname] = flag\n\t\tif _, set := f.actual[fname]; set {\n\t\t\tdelete(f.actual, fname)\n\t\t\tf.actual[nname] = flag\n\t\t}\n\t}\n}\n\n// GetNormalizeFunc returns the previously set NormalizeFunc of a function which\n// does no translation, if not set previously.\nfunc (f *FlagSet) GetNormalizeFunc() func(f *FlagSet, name string) NormalizedName {\n\tif f.normalizeNameFunc != nil {\n\t\treturn f.normalizeNameFunc\n\t}\n\treturn func(f *FlagSet, name string) NormalizedName { return NormalizedName(name) }\n}\n\nfunc (f *FlagSet) normalizeFlagName(name string) NormalizedName {\n\tn := f.GetNormalizeFunc()\n\treturn n(f, name)\n}\n\nfunc (f *FlagSet) out() io.Writer {\n\tif f.output == nil {\n\t\treturn os.Stderr\n\t}\n\treturn f.output\n}\n\n// SetOutput sets the destination for usage and error messages.\n// If output is nil, os.Stderr is used.\nfunc (f *FlagSet) SetOutput(output io.Writer) {\n\tf.output = output\n}\n\n// VisitAll visits the flags in lexicographical order or\n// in primordial order if f.SortFlags is false, calling fn for each.\n// It visits all flags, even those not set.\nfunc (f *FlagSet) VisitAll(fn func(*Flag)) {\n\tif len(f.formal) == 0 {\n\t\treturn\n\t}\n\n\tvar flags []*Flag\n\tif f.SortFlags {\n\t\tif len(f.formal) != len(f.sortedFormal) {\n\t\t\tf.sortedFormal = sortFlags(f.formal)\n\t\t}\n\t\tflags = f.sortedFormal\n\t} else {\n\t\tflags = f.orderedFormal\n\t}\n\n\tfor _, flag := range flags {\n\t\tfn(flag)\n\t}\n}\n\n// HasFlags returns a bool to indicate if the FlagSet has any flags defined.\nfunc (f *FlagSet) HasFlags() bool {\n\treturn len(f.formal) > 0\n}\n\n// HasAvailableFlags returns a bool to indicate if the FlagSet has any flags\n// that are not hidden.\nfunc (f *FlagSet) HasAvailableFlags() bool {\n\tfor _, flag := range f.formal {\n\t\tif !flag.Hidden {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// VisitAll visits the command-line flags in lexicographical order or\n// in primordial order if f.SortFlags is false, calling fn for each.\n// It visits all flags, even those not set.\nfunc VisitAll(fn func(*Flag)) {\n\tCommandLine.VisitAll(fn)\n}\n\n// Visit visits the flags in lexicographical order or\n// in primordial order if f.SortFlags is false, calling fn for each.\n// It visits only those flags that have been set.\nfunc (f *FlagSet) Visit(fn func(*Flag)) {\n\tif len(f.actual) == 0 {\n\t\treturn\n\t}\n\n\tvar flags []*Flag\n\tif f.SortFlags {\n\t\tif len(f.actual) != len(f.sortedActual) {\n\t\t\tf.sortedActual = sortFlags(f.actual)\n\t\t}\n\t\tflags = f.sortedActual\n\t} else {\n\t\tflags = f.orderedActual\n\t}\n\n\tfor _, flag := range flags {\n\t\tfn(flag)\n\t}\n}\n\n// Visit visits the command-line flags in lexicographical order or\n// in primordial order if f.SortFlags is false, calling fn for each.\n// It visits only those flags that have been set.\nfunc Visit(fn func(*Flag)) {\n\tCommandLine.Visit(fn)\n}\n\n// Lookup returns the Flag structure of the named flag, returning nil if none exists.\nfunc (f *FlagSet) Lookup(name string) *Flag {\n\treturn f.lookup(f.normalizeFlagName(name))\n}\n\n// ShorthandLookup returns the Flag structure of the short handed flag,\n// returning nil if none exists.\n// It panics, if len(name) > 1.\nfunc (f *FlagSet) ShorthandLookup(name string) *Flag {\n\tif name == \"\" {\n\t\treturn nil\n\t}\n\tif len(name) > 1 {\n\t\tmsg := fmt.Sprintf(\"can not look up shorthand which is more than one ASCII character: %q\", name)\n\t\tfmt.Fprintf(f.out(), msg)\n\t\tpanic(msg)\n\t}\n\tc := name[0]\n\treturn f.shorthands[c]\n}\n\n// lookup returns the Flag structure of the named flag, returning nil if none exists.\nfunc (f *FlagSet) lookup(name NormalizedName) *Flag {\n\treturn f.formal[name]\n}\n\n// func to return a given type for a given flag name\nfunc (f *FlagSet) getFlagType(name string, ftype string, convFunc func(sval string) (interface{}, error)) (interface{}, error) {\n\tflag := f.Lookup(name)\n\tif flag == nil {\n\t\terr := fmt.Errorf(\"flag accessed but not defined: %s\", name)\n\t\treturn nil, err\n\t}\n\n\tif flag.Value.Type() != ftype {\n\t\terr := fmt.Errorf(\"trying to get %s value of flag of type %s\", ftype, flag.Value.Type())\n\t\treturn nil, err\n\t}\n\n\tsval := flag.Value.String()\n\tresult, err := convFunc(sval)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn result, nil\n}\n\n// ArgsLenAtDash will return the length of f.Args at the moment when a -- was\n// found during arg parsing. This allows your program to know which args were\n// before the -- and which came after.\nfunc (f *FlagSet) ArgsLenAtDash() int {\n\treturn f.argsLenAtDash\n}\n\n// MarkDeprecated indicated that a flag is deprecated in your program. It will\n// continue to function but will not show up in help or usage messages. Using\n// this flag will also print the given usageMessage.\nfunc (f *FlagSet) MarkDeprecated(name string, usageMessage string) error {\n\tflag := f.Lookup(name)\n\tif flag == nil {\n\t\treturn fmt.Errorf(\"flag %q does not exist\", name)\n\t}\n\tif usageMessage == \"\" {\n\t\treturn fmt.Errorf(\"deprecated message for flag %q must be set\", name)\n\t}\n\tflag.Deprecated = usageMessage\n\tflag.Hidden = true\n\treturn nil\n}\n\n// MarkShorthandDeprecated will mark the shorthand of a flag deprecated in your\n// program. It will continue to function but will not show up in help or usage\n// messages. Using this flag will also print the given usageMessage.\nfunc (f *FlagSet) MarkShorthandDeprecated(name string, usageMessage string) error {\n\tflag := f.Lookup(name)\n\tif flag == nil {\n\t\treturn fmt.Errorf(\"flag %q does not exist\", name)\n\t}\n\tif usageMessage == \"\" {\n\t\treturn fmt.Errorf(\"deprecated message for flag %q must be set\", name)\n\t}\n\tflag.ShorthandDeprecated = usageMessage\n\treturn nil\n}\n\n// MarkHidden sets a flag to 'hidden' in your program. It will continue to\n// function but will not show up in help or usage messages.\nfunc (f *FlagSet) MarkHidden(name string) error {\n\tflag := f.Lookup(name)\n\tif flag == nil {\n\t\treturn fmt.Errorf(\"flag %q does not exist\", name)\n\t}\n\tflag.Hidden = true\n\treturn nil\n}\n\n// Lookup returns the Flag structure of the named command-line flag,\n// returning nil if none exists.\nfunc Lookup(name string) *Flag {\n\treturn CommandLine.Lookup(name)\n}\n\n// ShorthandLookup returns the Flag structure of the short handed flag,\n// returning nil if none exists.\nfunc ShorthandLookup(name string) *Flag {\n\treturn CommandLine.ShorthandLookup(name)\n}\n\n// Set sets the value of the named flag.\nfunc (f *FlagSet) Set(name, value string) error {\n\tnormalName := f.normalizeFlagName(name)\n\tflag, ok := f.formal[normalName]\n\tif !ok {\n\t\treturn fmt.Errorf(\"no such flag -%v\", name)\n\t}\n\n\terr := flag.Value.Set(value)\n\tif err != nil {\n\t\tvar flagName string\n\t\tif flag.Shorthand != \"\" && flag.ShorthandDeprecated == \"\" {\n\t\t\tflagName = fmt.Sprintf(\"-%s, --%s\", flag.Shorthand, flag.Name)\n\t\t} else {\n\t\t\tflagName = fmt.Sprintf(\"--%s\", flag.Name)\n\t\t}\n\t\treturn fmt.Errorf(\"invalid argument %q for %q flag: %v\", value, flagName, err)\n\t}\n\n\tif !flag.Changed {\n\t\tif f.actual == nil {\n\t\t\tf.actual = make(map[NormalizedName]*Flag)\n\t\t}\n\t\tf.actual[normalName] = flag\n\t\tf.orderedActual = append(f.orderedActual, flag)\n\n\t\tflag.Changed = true\n\t}\n\n\tif flag.Deprecated != \"\" {\n\t\tfmt.Fprintf(f.out(), \"Flag --%s has been deprecated, %s\\n\", flag.Name, flag.Deprecated)\n\t}\n\treturn nil\n}\n\n// SetAnnotation allows one to set arbitrary annotations on a flag in the FlagSet.\n// This is sometimes used by spf13/cobra programs which want to generate additional\n// bash completion information.\nfunc (f *FlagSet) SetAnnotation(name, key string, values []string) error {\n\tnormalName := f.normalizeFlagName(name)\n\tflag, ok := f.formal[normalName]\n\tif !ok {\n\t\treturn fmt.Errorf(\"no such flag -%v\", name)\n\t}\n\tif flag.Annotations == nil {\n\t\tflag.Annotations = map[string][]string{}\n\t}\n\tflag.Annotations[key] = values\n\treturn nil\n}\n\n// Changed returns true if the flag was explicitly set during Parse() and false\n// otherwise\nfunc (f *FlagSet) Changed(name string) bool {\n\tflag := f.Lookup(name)\n\t// If a flag doesn't exist, it wasn't changed....\n\tif flag == nil {\n\t\treturn false\n\t}\n\treturn flag.Changed\n}\n\n// Set sets the value of the named command-line flag.\nfunc Set(name, value string) error {\n\treturn CommandLine.Set(name, value)\n}\n\n// PrintDefaults prints, to standard error unless configured\n// otherwise, the default values of all defined flags in the set.\nfunc (f *FlagSet) PrintDefaults() {\n\tusages := f.FlagUsages()\n\tfmt.Fprint(f.out(), usages)\n}\n\n// defaultIsZeroValue returns true if the default value for this flag represents\n// a zero value.\nfunc (f *Flag) defaultIsZeroValue() bool {\n\tswitch f.Value.(type) {\n\tcase boolFlag:\n\t\treturn f.DefValue == \"false\"\n\tcase *durationValue:\n\t\t// Beginning in Go 1.7, duration zero values are \"0s\"\n\t\treturn f.DefValue == \"0\" || f.DefValue == \"0s\"\n\tcase *intValue, *int8Value, *int32Value, *int64Value, *uintValue, *uint8Value, *uint16Value, *uint32Value, *uint64Value, *countValue, *float32Value, *float64Value:\n\t\treturn f.DefValue == \"0\"\n\tcase *stringValue:\n\t\treturn f.DefValue == \"\"\n\tcase *ipValue, *ipMaskValue, *ipNetValue:\n\t\treturn f.DefValue == \"\"\n\tcase *intSliceValue, *stringSliceValue, *stringArrayValue:\n\t\treturn f.DefValue == \"[]\"\n\tdefault:\n\t\tswitch f.Value.String() {\n\t\tcase \"false\":\n\t\t\treturn true\n\t\tcase \"\":\n\t\t\treturn true\n\t\tcase \"\":\n\t\t\treturn true\n\t\tcase \"0\":\n\t\t\treturn true\n\t\t}\n\t\treturn false\n\t}\n}\n\n// UnquoteUsage extracts a back-quoted name from the usage\n// string for a flag and returns it and the un-quoted usage.\n// Given \"a `name` to show\" it returns (\"name\", \"a name to show\").\n// If there are no back quotes, the name is an educated guess of the\n// type of the flag's value, or the empty string if the flag is boolean.\nfunc UnquoteUsage(flag *Flag) (name string, usage string) {\n\t// Look for a back-quoted name, but avoid the strings package.\n\tusage = flag.Usage\n\tfor i := 0; i < len(usage); i++ {\n\t\tif usage[i] == '`' {\n\t\t\tfor j := i + 1; j < len(usage); j++ {\n\t\t\t\tif usage[j] == '`' {\n\t\t\t\t\tname = usage[i+1 : j]\n\t\t\t\t\tusage = usage[:i] + name + usage[j+1:]\n\t\t\t\t\treturn name, usage\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak // Only one back quote; use type name.\n\t\t}\n\t}\n\n\tname = flag.Value.Type()\n\tswitch name {\n\tcase \"bool\":\n\t\tname = \"\"\n\tcase \"float64\":\n\t\tname = \"float\"\n\tcase \"int64\":\n\t\tname = \"int\"\n\tcase \"uint64\":\n\t\tname = \"uint\"\n\tcase \"stringSlice\":\n\t\tname = \"strings\"\n\tcase \"intSlice\":\n\t\tname = \"ints\"\n\tcase \"uintSlice\":\n\t\tname = \"uints\"\n\tcase \"boolSlice\":\n\t\tname = \"bools\"\n\t}\n\n\treturn\n}\n\n// Splits the string `s` on whitespace into an initial substring up to\n// `i` runes in length and the remainder. Will go `slop` over `i` if\n// that encompasses the entire string (which allows the caller to\n// avoid short orphan words on the final line).\nfunc wrapN(i, slop int, s string) (string, string) {\n\tif i+slop > len(s) {\n\t\treturn s, \"\"\n\t}\n\n\tw := strings.LastIndexAny(s[:i], \" \\t\\n\")\n\tif w <= 0 {\n\t\treturn s, \"\"\n\t}\n\tnlPos := strings.LastIndex(s[:i], \"\\n\")\n\tif nlPos > 0 && nlPos < w {\n\t\treturn s[:nlPos], s[nlPos+1:]\n\t}\n\treturn s[:w], s[w+1:]\n}\n\n// Wraps the string `s` to a maximum width `w` with leading indent\n// `i`. The first line is not indented (this is assumed to be done by\n// caller). Pass `w` == 0 to do no wrapping\nfunc wrap(i, w int, s string) string {\n\tif w == 0 {\n\t\treturn strings.Replace(s, \"\\n\", \"\\n\"+strings.Repeat(\" \", i), -1)\n\t}\n\n\t// space between indent i and end of line width w into which\n\t// we should wrap the text.\n\twrap := w - i\n\n\tvar r, l string\n\n\t// Not enough space for sensible wrapping. Wrap as a block on\n\t// the next line instead.\n\tif wrap < 24 {\n\t\ti = 16\n\t\twrap = w - i\n\t\tr += \"\\n\" + strings.Repeat(\" \", i)\n\t}\n\t// If still not enough space then don't even try to wrap.\n\tif wrap < 24 {\n\t\treturn strings.Replace(s, \"\\n\", r, -1)\n\t}\n\n\t// Try to avoid short orphan words on the final line, by\n\t// allowing wrapN to go a bit over if that would fit in the\n\t// remainder of the line.\n\tslop := 5\n\twrap = wrap - slop\n\n\t// Handle first line, which is indented by the caller (or the\n\t// special case above)\n\tl, s = wrapN(wrap, slop, s)\n\tr = r + strings.Replace(l, \"\\n\", \"\\n\"+strings.Repeat(\" \", i), -1)\n\n\t// Now wrap the rest\n\tfor s != \"\" {\n\t\tvar t string\n\n\t\tt, s = wrapN(wrap, slop, s)\n\t\tr = r + \"\\n\" + strings.Repeat(\" \", i) + strings.Replace(t, \"\\n\", \"\\n\"+strings.Repeat(\" \", i), -1)\n\t}\n\n\treturn r\n\n}\n\n// FlagUsagesWrapped returns a string containing the usage information\n// for all flags in the FlagSet. Wrapped to `cols` columns (0 for no\n// wrapping)\nfunc (f *FlagSet) FlagUsagesWrapped(cols int) string {\n\tbuf := new(bytes.Buffer)\n\n\tlines := make([]string, 0, len(f.formal))\n\n\tmaxlen := 0\n\tf.VisitAll(func(flag *Flag) {\n\t\tif flag.Hidden {\n\t\t\treturn\n\t\t}\n\n\t\tline := \"\"\n\t\tif flag.Shorthand != \"\" && flag.ShorthandDeprecated == \"\" {\n\t\t\tline = fmt.Sprintf(\" -%s, --%s\", flag.Shorthand, flag.Name)\n\t\t} else {\n\t\t\tline = fmt.Sprintf(\" --%s\", flag.Name)\n\t\t}\n\n\t\tvarname, usage := UnquoteUsage(flag)\n\t\tif varname != \"\" {\n\t\t\tline += \" \" + varname\n\t\t}\n\t\tif flag.NoOptDefVal != \"\" {\n\t\t\tswitch flag.Value.Type() {\n\t\t\tcase \"string\":\n\t\t\t\tline += fmt.Sprintf(\"[=\\\"%s\\\"]\", flag.NoOptDefVal)\n\t\t\tcase \"bool\":\n\t\t\t\tif flag.NoOptDefVal != \"true\" {\n\t\t\t\t\tline += fmt.Sprintf(\"[=%s]\", flag.NoOptDefVal)\n\t\t\t\t}\n\t\t\tcase \"count\":\n\t\t\t\tif flag.NoOptDefVal != \"+1\" {\n\t\t\t\t\tline += fmt.Sprintf(\"[=%s]\", flag.NoOptDefVal)\n\t\t\t\t}\n\t\t\tdefault:\n\t\t\t\tline += fmt.Sprintf(\"[=%s]\", flag.NoOptDefVal)\n\t\t\t}\n\t\t}\n\n\t\t// This special character will be replaced with spacing once the\n\t\t// correct alignment is calculated\n\t\tline += \"\\x00\"\n\t\tif len(line) > maxlen {\n\t\t\tmaxlen = len(line)\n\t\t}\n\n\t\tline += usage\n\t\tif !flag.defaultIsZeroValue() {\n\t\t\tif flag.Value.Type() == \"string\" {\n\t\t\t\tline += fmt.Sprintf(\" (default %q)\", flag.DefValue)\n\t\t\t} else {\n\t\t\t\tline += fmt.Sprintf(\" (default %s)\", flag.DefValue)\n\t\t\t}\n\t\t}\n\t\tif len(flag.Deprecated) != 0 {\n\t\t\tline += fmt.Sprintf(\" (DEPRECATED: %s)\", flag.Deprecated)\n\t\t}\n\n\t\tlines = append(lines, line)\n\t})\n\n\tfor _, line := range lines {\n\t\tsidx := strings.Index(line, \"\\x00\")\n\t\tspacing := strings.Repeat(\" \", maxlen-sidx)\n\t\t// maxlen + 2 comes from + 1 for the \\x00 and + 1 for the (deliberate) off-by-one in maxlen-sidx\n\t\tfmt.Fprintln(buf, line[:sidx], spacing, wrap(maxlen+2, cols, line[sidx+1:]))\n\t}\n\n\treturn buf.String()\n}\n\n// FlagUsages returns a string containing the usage information for all flags in\n// the FlagSet\nfunc (f *FlagSet) FlagUsages() string {\n\treturn f.FlagUsagesWrapped(0)\n}\n\n// PrintDefaults prints to standard error the default values of all defined command-line flags.\nfunc PrintDefaults() {\n\tCommandLine.PrintDefaults()\n}\n\n// defaultUsage is the default function to print a usage message.\nfunc defaultUsage(f *FlagSet) {\n\tfmt.Fprintf(f.out(), \"Usage of %s:\\n\", f.name)\n\tf.PrintDefaults()\n}\n\n// NOTE: Usage is not just defaultUsage(CommandLine)\n// because it serves (via godoc flag Usage) as the example\n// for how to write your own usage function.\n\n// Usage prints to standard error a usage message documenting all defined command-line flags.\n// The function is a variable that may be changed to point to a custom function.\n// By default it prints a simple header and calls PrintDefaults; for details about the\n// format of the output and how to control it, see the documentation for PrintDefaults.\nvar Usage = func() {\n\tfmt.Fprintf(os.Stderr, \"Usage of %s:\\n\", os.Args[0])\n\tPrintDefaults()\n}\n\n// NFlag returns the number of flags that have been set.\nfunc (f *FlagSet) NFlag() int { return len(f.actual) }\n\n// NFlag returns the number of command-line flags that have been set.\nfunc NFlag() int { return len(CommandLine.actual) }\n\n// Arg returns the i'th argument. Arg(0) is the first remaining argument\n// after flags have been processed.\nfunc (f *FlagSet) Arg(i int) string {\n\tif i < 0 || i >= len(f.args) {\n\t\treturn \"\"\n\t}\n\treturn f.args[i]\n}\n\n// Arg returns the i'th command-line argument. Arg(0) is the first remaining argument\n// after flags have been processed.\nfunc Arg(i int) string {\n\treturn CommandLine.Arg(i)\n}\n\n// NArg is the number of arguments remaining after flags have been processed.\nfunc (f *FlagSet) NArg() int { return len(f.args) }\n\n// NArg is the number of arguments remaining after flags have been processed.\nfunc NArg() int { return len(CommandLine.args) }\n\n// Args returns the non-flag arguments.\nfunc (f *FlagSet) Args() []string { return f.args }\n\n// Args returns the non-flag command-line arguments.\nfunc Args() []string { return CommandLine.args }\n\n// Var defines a flag with the specified name and usage string. The type and\n// value of the flag are represented by the first argument, of type Value, which\n// typically holds a user-defined implementation of Value. For instance, the\n// caller could create a flag that turns a comma-separated string into a slice\n// of strings by giving the slice the methods of Value; in particular, Set would\n// decompose the comma-separated string into the slice.\nfunc (f *FlagSet) Var(value Value, name string, usage string) {\n\tf.VarP(value, name, \"\", usage)\n}\n\n// VarPF is like VarP, but returns the flag created\nfunc (f *FlagSet) VarPF(value Value, name, shorthand, usage string) *Flag {\n\t// Remember the default value as a string; it won't change.\n\tflag := &Flag{\n\t\tName: name,\n\t\tShorthand: shorthand,\n\t\tUsage: usage,\n\t\tValue: value,\n\t\tDefValue: value.String(),\n\t}\n\tf.AddFlag(flag)\n\treturn flag\n}\n\n// VarP is like Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) VarP(value Value, name, shorthand, usage string) {\n\tf.VarPF(value, name, shorthand, usage)\n}\n\n// AddFlag will add the flag to the FlagSet\nfunc (f *FlagSet) AddFlag(flag *Flag) {\n\tnormalizedFlagName := f.normalizeFlagName(flag.Name)\n\n\t_, alreadyThere := f.formal[normalizedFlagName]\n\tif alreadyThere {\n\t\tmsg := fmt.Sprintf(\"%s flag redefined: %s\", f.name, flag.Name)\n\t\tfmt.Fprintln(f.out(), msg)\n\t\tpanic(msg) // Happens only if flags are declared with identical names\n\t}\n\tif f.formal == nil {\n\t\tf.formal = make(map[NormalizedName]*Flag)\n\t}\n\n\tflag.Name = string(normalizedFlagName)\n\tf.formal[normalizedFlagName] = flag\n\tf.orderedFormal = append(f.orderedFormal, flag)\n\n\tif flag.Shorthand == \"\" {\n\t\treturn\n\t}\n\tif len(flag.Shorthand) > 1 {\n\t\tmsg := fmt.Sprintf(\"%q shorthand is more than one ASCII character\", flag.Shorthand)\n\t\tfmt.Fprintf(f.out(), msg)\n\t\tpanic(msg)\n\t}\n\tif f.shorthands == nil {\n\t\tf.shorthands = make(map[byte]*Flag)\n\t}\n\tc := flag.Shorthand[0]\n\tused, alreadyThere := f.shorthands[c]\n\tif alreadyThere {\n\t\tmsg := fmt.Sprintf(\"unable to redefine %q shorthand in %q flagset: it's already used for %q flag\", c, f.name, used.Name)\n\t\tfmt.Fprintf(f.out(), msg)\n\t\tpanic(msg)\n\t}\n\tf.shorthands[c] = flag\n}\n\n// AddFlagSet adds one FlagSet to another. If a flag is already present in f\n// the flag from newSet will be ignored.\nfunc (f *FlagSet) AddFlagSet(newSet *FlagSet) {\n\tif newSet == nil {\n\t\treturn\n\t}\n\tnewSet.VisitAll(func(flag *Flag) {\n\t\tif f.Lookup(flag.Name) == nil {\n\t\t\tf.AddFlag(flag)\n\t\t}\n\t})\n}\n\n// Var defines a flag with the specified name and usage string. The type and\n// value of the flag are represented by the first argument, of type Value, which\n// typically holds a user-defined implementation of Value. For instance, the\n// caller could create a flag that turns a comma-separated string into a slice\n// of strings by giving the slice the methods of Value; in particular, Set would\n// decompose the comma-separated string into the slice.\nfunc Var(value Value, name string, usage string) {\n\tCommandLine.VarP(value, name, \"\", usage)\n}\n\n// VarP is like Var, but accepts a shorthand letter that can be used after a single dash.\nfunc VarP(value Value, name, shorthand, usage string) {\n\tCommandLine.VarP(value, name, shorthand, usage)\n}\n\n// failf prints to standard error a formatted error and usage message and\n// returns the error.\nfunc (f *FlagSet) failf(format string, a ...interface{}) error {\n\terr := fmt.Errorf(format, a...)\n\tif f.errorHandling != ContinueOnError {\n\t\tfmt.Fprintln(f.out(), err)\n\t\tf.usage()\n\t}\n\treturn err\n}\n\n// usage calls the Usage method for the flag set, or the usage function if\n// the flag set is CommandLine.\nfunc (f *FlagSet) usage() {\n\tif f == CommandLine {\n\t\tUsage()\n\t} else if f.Usage == nil {\n\t\tdefaultUsage(f)\n\t} else {\n\t\tf.Usage()\n\t}\n}\n\n//--unknown (args will be empty)\n//--unknown --next-flag ... (args will be --next-flag ...)\n//--unknown arg ... (args will be arg ...)\nfunc stripUnknownFlagValue(args []string) []string {\n\tif len(args) == 0 {\n\t\t//--unknown\n\t\treturn args\n\t}\n\n\tfirst := args[0]\n\tif len(first) > 0 && first[0] == '-' {\n\t\t//--unknown --next-flag ...\n\t\treturn args\n\t}\n\n\t//--unknown arg ... (args will be arg ...)\n\tif len(args) > 1 {\n\t\treturn args[1:]\n\t}\n\treturn nil\n}\n\nfunc (f *FlagSet) parseLongArg(s string, args []string, fn parseFunc) (a []string, err error) {\n\ta = args\n\tname := s[2:]\n\tif len(name) == 0 || name[0] == '-' || name[0] == '=' {\n\t\terr = f.failf(\"bad flag syntax: %s\", s)\n\t\treturn\n\t}\n\n\tsplit := strings.SplitN(name, \"=\", 2)\n\tname = split[0]\n\tflag, exists := f.formal[f.normalizeFlagName(name)]\n\n\tif !exists {\n\t\tswitch {\n\t\tcase name == \"help\":\n\t\t\tf.usage()\n\t\t\treturn a, ErrHelp\n\t\tcase f.ParseErrorsWhitelist.UnknownFlags:\n\t\t\t// --unknown=unknownval arg ...\n\t\t\t// we do not want to lose arg in this case\n\t\t\tif len(split) >= 2 {\n\t\t\t\treturn a, nil\n\t\t\t}\n\n\t\t\treturn stripUnknownFlagValue(a), nil\n\t\tdefault:\n\t\t\terr = f.failf(\"unknown flag: --%s\", name)\n\t\t\treturn\n\t\t}\n\t}\n\n\tvar value string\n\tif len(split) == 2 {\n\t\t// '--flag=arg'\n\t\tvalue = split[1]\n\t} else if flag.NoOptDefVal != \"\" {\n\t\t// '--flag' (arg was optional)\n\t\tvalue = flag.NoOptDefVal\n\t} else if len(a) > 0 {\n\t\t// '--flag arg'\n\t\tvalue = a[0]\n\t\ta = a[1:]\n\t} else {\n\t\t// '--flag' (arg was required)\n\t\terr = f.failf(\"flag needs an argument: %s\", s)\n\t\treturn\n\t}\n\n\terr = fn(flag, value)\n\tif err != nil {\n\t\tf.failf(err.Error())\n\t}\n\treturn\n}\n\nfunc (f *FlagSet) parseSingleShortArg(shorthands string, args []string, fn parseFunc) (outShorts string, outArgs []string, err error) {\n\toutArgs = args\n\n\tif strings.HasPrefix(shorthands, \"test.\") {\n\t\treturn\n\t}\n\n\toutShorts = shorthands[1:]\n\tc := shorthands[0]\n\n\tflag, exists := f.shorthands[c]\n\tif !exists {\n\t\tswitch {\n\t\tcase c == 'h':\n\t\t\tf.usage()\n\t\t\terr = ErrHelp\n\t\t\treturn\n\t\tcase f.ParseErrorsWhitelist.UnknownFlags:\n\t\t\t// '-f=arg arg ...'\n\t\t\t// we do not want to lose arg in this case\n\t\t\tif len(shorthands) > 2 && shorthands[1] == '=' {\n\t\t\t\toutShorts = \"\"\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\toutArgs = stripUnknownFlagValue(outArgs)\n\t\t\treturn\n\t\tdefault:\n\t\t\terr = f.failf(\"unknown shorthand flag: %q in -%s\", c, shorthands)\n\t\t\treturn\n\t\t}\n\t}\n\n\tvar value string\n\tif len(shorthands) > 2 && shorthands[1] == '=' {\n\t\t// '-f=arg'\n\t\tvalue = shorthands[2:]\n\t\toutShorts = \"\"\n\t} else if flag.NoOptDefVal != \"\" {\n\t\t// '-f' (arg was optional)\n\t\tvalue = flag.NoOptDefVal\n\t} else if len(shorthands) > 1 {\n\t\t// '-farg'\n\t\tvalue = shorthands[1:]\n\t\toutShorts = \"\"\n\t} else if len(args) > 0 {\n\t\t// '-f arg'\n\t\tvalue = args[0]\n\t\toutArgs = args[1:]\n\t} else {\n\t\t// '-f' (arg was required)\n\t\terr = f.failf(\"flag needs an argument: %q in -%s\", c, shorthands)\n\t\treturn\n\t}\n\n\tif flag.ShorthandDeprecated != \"\" {\n\t\tfmt.Fprintf(f.out(), \"Flag shorthand -%s has been deprecated, %s\\n\", flag.Shorthand, flag.ShorthandDeprecated)\n\t}\n\n\terr = fn(flag, value)\n\tif err != nil {\n\t\tf.failf(err.Error())\n\t}\n\treturn\n}\n\nfunc (f *FlagSet) parseShortArg(s string, args []string, fn parseFunc) (a []string, err error) {\n\ta = args\n\tshorthands := s[1:]\n\n\t// \"shorthands\" can be a series of shorthand letters of flags (e.g. \"-vvv\").\n\tfor len(shorthands) > 0 {\n\t\tshorthands, a, err = f.parseSingleShortArg(shorthands, args, fn)\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\n\treturn\n}\n\nfunc (f *FlagSet) parseArgs(args []string, fn parseFunc) (err error) {\n\tfor len(args) > 0 {\n\t\ts := args[0]\n\t\targs = args[1:]\n\t\tif len(s) == 0 || s[0] != '-' || len(s) == 1 {\n\t\t\tif !f.interspersed {\n\t\t\t\tf.args = append(f.args, s)\n\t\t\t\tf.args = append(f.args, args...)\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\tf.args = append(f.args, s)\n\t\t\tcontinue\n\t\t}\n\n\t\tif s[1] == '-' {\n\t\t\tif len(s) == 2 { // \"--\" terminates the flags\n\t\t\t\tf.argsLenAtDash = len(f.args)\n\t\t\t\tf.args = append(f.args, args...)\n\t\t\t\tbreak\n\t\t\t}\n\t\t\targs, err = f.parseLongArg(s, args, fn)\n\t\t} else {\n\t\t\targs, err = f.parseShortArg(s, args, fn)\n\t\t}\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t}\n\treturn\n}\n\n// Parse parses flag definitions from the argument list, which should not\n// include the command name. Must be called after all flags in the FlagSet\n// are defined and before flags are accessed by the program.\n// The return value will be ErrHelp if -help was set but not defined.\nfunc (f *FlagSet) Parse(arguments []string) error {\n\tif f.addedGoFlagSets != nil {\n\t\tfor _, goFlagSet := range f.addedGoFlagSets {\n\t\t\tgoFlagSet.Parse(nil)\n\t\t}\n\t}\n\tf.parsed = true\n\n\tif len(arguments) < 0 {\n\t\treturn nil\n\t}\n\n\tf.args = make([]string, 0, len(arguments))\n\n\tset := func(flag *Flag, value string) error {\n\t\treturn f.Set(flag.Name, value)\n\t}\n\n\terr := f.parseArgs(arguments, set)\n\tif err != nil {\n\t\tswitch f.errorHandling {\n\t\tcase ContinueOnError:\n\t\t\treturn err\n\t\tcase ExitOnError:\n\t\t\tfmt.Println(err)\n\t\t\tos.Exit(2)\n\t\tcase PanicOnError:\n\t\t\tpanic(err)\n\t\t}\n\t}\n\treturn nil\n}\n\ntype parseFunc func(flag *Flag, value string) error\n\n// ParseAll parses flag definitions from the argument list, which should not\n// include the command name. The arguments for fn are flag and value. Must be\n// called after all flags in the FlagSet are defined and before flags are\n// accessed by the program. The return value will be ErrHelp if -help was set\n// but not defined.\nfunc (f *FlagSet) ParseAll(arguments []string, fn func(flag *Flag, value string) error) error {\n\tf.parsed = true\n\tf.args = make([]string, 0, len(arguments))\n\n\terr := f.parseArgs(arguments, fn)\n\tif err != nil {\n\t\tswitch f.errorHandling {\n\t\tcase ContinueOnError:\n\t\t\treturn err\n\t\tcase ExitOnError:\n\t\t\tos.Exit(2)\n\t\tcase PanicOnError:\n\t\t\tpanic(err)\n\t\t}\n\t}\n\treturn nil\n}\n\n// Parsed reports whether f.Parse has been called.\nfunc (f *FlagSet) Parsed() bool {\n\treturn f.parsed\n}\n\n// Parse parses the command-line flags from os.Args[1:]. Must be called\n// after all flags are defined and before flags are accessed by the program.\nfunc Parse() {\n\t// Ignore errors; CommandLine is set for ExitOnError.\n\tCommandLine.Parse(os.Args[1:])\n}\n\n// ParseAll parses the command-line flags from os.Args[1:] and called fn for each.\n// The arguments for fn are flag and value. Must be called after all flags are\n// defined and before flags are accessed by the program.\nfunc ParseAll(fn func(flag *Flag, value string) error) {\n\t// Ignore errors; CommandLine is set for ExitOnError.\n\tCommandLine.ParseAll(os.Args[1:], fn)\n}\n\n// SetInterspersed sets whether to support interspersed option/non-option arguments.\nfunc SetInterspersed(interspersed bool) {\n\tCommandLine.SetInterspersed(interspersed)\n}\n\n// Parsed returns true if the command-line flags have been parsed.\nfunc Parsed() bool {\n\treturn CommandLine.Parsed()\n}\n\n// CommandLine is the default set of command-line flags, parsed from os.Args.\nvar CommandLine = NewFlagSet(os.Args[0], ExitOnError)\n\n// NewFlagSet returns a new, empty flag set with the specified name,\n// error handling property and SortFlags set to true.\nfunc NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {\n\tf := &FlagSet{\n\t\tname: name,\n\t\terrorHandling: errorHandling,\n\t\targsLenAtDash: -1,\n\t\tinterspersed: true,\n\t\tSortFlags: true,\n\t}\n\treturn f\n}\n\n// SetInterspersed sets whether to support interspersed option/non-option arguments.\nfunc (f *FlagSet) SetInterspersed(interspersed bool) {\n\tf.interspersed = interspersed\n}\n\n// Init sets the name and error handling property for a flag set.\n// By default, the zero FlagSet uses an empty name and the\n// ContinueOnError error handling policy.\nfunc (f *FlagSet) Init(name string, errorHandling ErrorHandling) {\n\tf.name = name\n\tf.errorHandling = errorHandling\n\tf.argsLenAtDash = -1\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/float32.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- float32 Value\ntype float32Value float32\n\nfunc newFloat32Value(val float32, p *float32) *float32Value {\n\t*p = val\n\treturn (*float32Value)(p)\n}\n\nfunc (f *float32Value) Set(s string) error {\n\tv, err := strconv.ParseFloat(s, 32)\n\t*f = float32Value(v)\n\treturn err\n}\n\nfunc (f *float32Value) Type() string {\n\treturn \"float32\"\n}\n\nfunc (f *float32Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 32) }\n\nfunc float32Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseFloat(sval, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn float32(v), nil\n}\n\n// GetFloat32 return the float32 value of a flag with the given name\nfunc (f *FlagSet) GetFloat32(name string) (float32, error) {\n\tval, err := f.getFlagType(name, \"float32\", float32Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(float32), nil\n}\n\n// Float32Var defines a float32 flag with specified name, default value, and usage string.\n// The argument p points to a float32 variable in which to store the value of the flag.\nfunc (f *FlagSet) Float32Var(p *float32, name string, value float32, usage string) {\n\tf.VarP(newFloat32Value(value, p), name, \"\", usage)\n}\n\n// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float32VarP(p *float32, name, shorthand string, value float32, usage string) {\n\tf.VarP(newFloat32Value(value, p), name, shorthand, usage)\n}\n\n// Float32Var defines a float32 flag with specified name, default value, and usage string.\n// The argument p points to a float32 variable in which to store the value of the flag.\nfunc Float32Var(p *float32, name string, value float32, usage string) {\n\tCommandLine.VarP(newFloat32Value(value, p), name, \"\", usage)\n}\n\n// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Float32VarP(p *float32, name, shorthand string, value float32, usage string) {\n\tCommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage)\n}\n\n// Float32 defines a float32 flag with specified name, default value, and usage string.\n// The return value is the address of a float32 variable that stores the value of the flag.\nfunc (f *FlagSet) Float32(name string, value float32, usage string) *float32 {\n\tp := new(float32)\n\tf.Float32VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float32P(name, shorthand string, value float32, usage string) *float32 {\n\tp := new(float32)\n\tf.Float32VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Float32 defines a float32 flag with specified name, default value, and usage string.\n// The return value is the address of a float32 variable that stores the value of the flag.\nfunc Float32(name string, value float32, usage string) *float32 {\n\treturn CommandLine.Float32P(name, \"\", value, usage)\n}\n\n// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.\nfunc Float32P(name, shorthand string, value float32, usage string) *float32 {\n\treturn CommandLine.Float32P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/float32_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- float32Slice Value\ntype float32SliceValue struct {\n\tvalue *[]float32\n\tchanged bool\n}\n\nfunc newFloat32SliceValue(val []float32, p *[]float32) *float32SliceValue {\n\tisv := new(float32SliceValue)\n\tisv.value = p\n\t*isv.value = val\n\treturn isv\n}\n\nfunc (s *float32SliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]float32, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tvar temp64 float64\n\t\ttemp64, err = strconv.ParseFloat(d, 32)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tout[i] = float32(temp64)\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *float32SliceValue) Type() string {\n\treturn \"float32Slice\"\n}\n\nfunc (s *float32SliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%f\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *float32SliceValue) fromString(val string) (float32, error) {\n\tt64, err := strconv.ParseFloat(val, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn float32(t64), nil\n}\n\nfunc (s *float32SliceValue) toString(val float32) string {\n\treturn fmt.Sprintf(\"%f\", val)\n}\n\nfunc (s *float32SliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *float32SliceValue) Replace(val []string) error {\n\tout := make([]float32, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *float32SliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc float32SliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []float32{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]float32, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tvar temp64 float64\n\t\ttemp64, err = strconv.ParseFloat(d, 32)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tout[i] = float32(temp64)\n\n\t}\n\treturn out, nil\n}\n\n// GetFloat32Slice return the []float32 value of a flag with the given name\nfunc (f *FlagSet) GetFloat32Slice(name string) ([]float32, error) {\n\tval, err := f.getFlagType(name, \"float32Slice\", float32SliceConv)\n\tif err != nil {\n\t\treturn []float32{}, err\n\t}\n\treturn val.([]float32), nil\n}\n\n// Float32SliceVar defines a float32Slice flag with specified name, default value, and usage string.\n// The argument p points to a []float32 variable in which to store the value of the flag.\nfunc (f *FlagSet) Float32SliceVar(p *[]float32, name string, value []float32, usage string) {\n\tf.VarP(newFloat32SliceValue(value, p), name, \"\", usage)\n}\n\n// Float32SliceVarP is like Float32SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float32SliceVarP(p *[]float32, name, shorthand string, value []float32, usage string) {\n\tf.VarP(newFloat32SliceValue(value, p), name, shorthand, usage)\n}\n\n// Float32SliceVar defines a float32[] flag with specified name, default value, and usage string.\n// The argument p points to a float32[] variable in which to store the value of the flag.\nfunc Float32SliceVar(p *[]float32, name string, value []float32, usage string) {\n\tCommandLine.VarP(newFloat32SliceValue(value, p), name, \"\", usage)\n}\n\n// Float32SliceVarP is like Float32SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc Float32SliceVarP(p *[]float32, name, shorthand string, value []float32, usage string) {\n\tCommandLine.VarP(newFloat32SliceValue(value, p), name, shorthand, usage)\n}\n\n// Float32Slice defines a []float32 flag with specified name, default value, and usage string.\n// The return value is the address of a []float32 variable that stores the value of the flag.\nfunc (f *FlagSet) Float32Slice(name string, value []float32, usage string) *[]float32 {\n\tp := []float32{}\n\tf.Float32SliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// Float32SliceP is like Float32Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float32SliceP(name, shorthand string, value []float32, usage string) *[]float32 {\n\tp := []float32{}\n\tf.Float32SliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// Float32Slice defines a []float32 flag with specified name, default value, and usage string.\n// The return value is the address of a []float32 variable that stores the value of the flag.\nfunc Float32Slice(name string, value []float32, usage string) *[]float32 {\n\treturn CommandLine.Float32SliceP(name, \"\", value, usage)\n}\n\n// Float32SliceP is like Float32Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc Float32SliceP(name, shorthand string, value []float32, usage string) *[]float32 {\n\treturn CommandLine.Float32SliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/float64.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- float64 Value\ntype float64Value float64\n\nfunc newFloat64Value(val float64, p *float64) *float64Value {\n\t*p = val\n\treturn (*float64Value)(p)\n}\n\nfunc (f *float64Value) Set(s string) error {\n\tv, err := strconv.ParseFloat(s, 64)\n\t*f = float64Value(v)\n\treturn err\n}\n\nfunc (f *float64Value) Type() string {\n\treturn \"float64\"\n}\n\nfunc (f *float64Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 64) }\n\nfunc float64Conv(sval string) (interface{}, error) {\n\treturn strconv.ParseFloat(sval, 64)\n}\n\n// GetFloat64 return the float64 value of a flag with the given name\nfunc (f *FlagSet) GetFloat64(name string) (float64, error) {\n\tval, err := f.getFlagType(name, \"float64\", float64Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(float64), nil\n}\n\n// Float64Var defines a float64 flag with specified name, default value, and usage string.\n// The argument p points to a float64 variable in which to store the value of the flag.\nfunc (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) {\n\tf.VarP(newFloat64Value(value, p), name, \"\", usage)\n}\n\n// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) {\n\tf.VarP(newFloat64Value(value, p), name, shorthand, usage)\n}\n\n// Float64Var defines a float64 flag with specified name, default value, and usage string.\n// The argument p points to a float64 variable in which to store the value of the flag.\nfunc Float64Var(p *float64, name string, value float64, usage string) {\n\tCommandLine.VarP(newFloat64Value(value, p), name, \"\", usage)\n}\n\n// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Float64VarP(p *float64, name, shorthand string, value float64, usage string) {\n\tCommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)\n}\n\n// Float64 defines a float64 flag with specified name, default value, and usage string.\n// The return value is the address of a float64 variable that stores the value of the flag.\nfunc (f *FlagSet) Float64(name string, value float64, usage string) *float64 {\n\tp := new(float64)\n\tf.Float64VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 {\n\tp := new(float64)\n\tf.Float64VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Float64 defines a float64 flag with specified name, default value, and usage string.\n// The return value is the address of a float64 variable that stores the value of the flag.\nfunc Float64(name string, value float64, usage string) *float64 {\n\treturn CommandLine.Float64P(name, \"\", value, usage)\n}\n\n// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.\nfunc Float64P(name, shorthand string, value float64, usage string) *float64 {\n\treturn CommandLine.Float64P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/float64_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- float64Slice Value\ntype float64SliceValue struct {\n\tvalue *[]float64\n\tchanged bool\n}\n\nfunc newFloat64SliceValue(val []float64, p *[]float64) *float64SliceValue {\n\tisv := new(float64SliceValue)\n\tisv.value = p\n\t*isv.value = val\n\treturn isv\n}\n\nfunc (s *float64SliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]float64, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.ParseFloat(d, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *float64SliceValue) Type() string {\n\treturn \"float64Slice\"\n}\n\nfunc (s *float64SliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%f\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *float64SliceValue) fromString(val string) (float64, error) {\n\treturn strconv.ParseFloat(val, 64)\n}\n\nfunc (s *float64SliceValue) toString(val float64) string {\n\treturn fmt.Sprintf(\"%f\", val)\n}\n\nfunc (s *float64SliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *float64SliceValue) Replace(val []string) error {\n\tout := make([]float64, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *float64SliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc float64SliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []float64{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]float64, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.ParseFloat(d, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t}\n\treturn out, nil\n}\n\n// GetFloat64Slice return the []float64 value of a flag with the given name\nfunc (f *FlagSet) GetFloat64Slice(name string) ([]float64, error) {\n\tval, err := f.getFlagType(name, \"float64Slice\", float64SliceConv)\n\tif err != nil {\n\t\treturn []float64{}, err\n\t}\n\treturn val.([]float64), nil\n}\n\n// Float64SliceVar defines a float64Slice flag with specified name, default value, and usage string.\n// The argument p points to a []float64 variable in which to store the value of the flag.\nfunc (f *FlagSet) Float64SliceVar(p *[]float64, name string, value []float64, usage string) {\n\tf.VarP(newFloat64SliceValue(value, p), name, \"\", usage)\n}\n\n// Float64SliceVarP is like Float64SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float64SliceVarP(p *[]float64, name, shorthand string, value []float64, usage string) {\n\tf.VarP(newFloat64SliceValue(value, p), name, shorthand, usage)\n}\n\n// Float64SliceVar defines a float64[] flag with specified name, default value, and usage string.\n// The argument p points to a float64[] variable in which to store the value of the flag.\nfunc Float64SliceVar(p *[]float64, name string, value []float64, usage string) {\n\tCommandLine.VarP(newFloat64SliceValue(value, p), name, \"\", usage)\n}\n\n// Float64SliceVarP is like Float64SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc Float64SliceVarP(p *[]float64, name, shorthand string, value []float64, usage string) {\n\tCommandLine.VarP(newFloat64SliceValue(value, p), name, shorthand, usage)\n}\n\n// Float64Slice defines a []float64 flag with specified name, default value, and usage string.\n// The return value is the address of a []float64 variable that stores the value of the flag.\nfunc (f *FlagSet) Float64Slice(name string, value []float64, usage string) *[]float64 {\n\tp := []float64{}\n\tf.Float64SliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// Float64SliceP is like Float64Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Float64SliceP(name, shorthand string, value []float64, usage string) *[]float64 {\n\tp := []float64{}\n\tf.Float64SliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// Float64Slice defines a []float64 flag with specified name, default value, and usage string.\n// The return value is the address of a []float64 variable that stores the value of the flag.\nfunc Float64Slice(name string, value []float64, usage string) *[]float64 {\n\treturn CommandLine.Float64SliceP(name, \"\", value, usage)\n}\n\n// Float64SliceP is like Float64Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc Float64SliceP(name, shorthand string, value []float64, usage string) *[]float64 {\n\treturn CommandLine.Float64SliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/golangflag.go",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage pflag\n\nimport (\n\tgoflag \"flag\"\n\t\"reflect\"\n\t\"strings\"\n)\n\n// flagValueWrapper implements pflag.Value around a flag.Value. The main\n// difference here is the addition of the Type method that returns a string\n// name of the type. As this is generally unknown, we approximate that with\n// reflection.\ntype flagValueWrapper struct {\n\tinner goflag.Value\n\tflagType string\n}\n\n// We are just copying the boolFlag interface out of goflag as that is what\n// they use to decide if a flag should get \"true\" when no arg is given.\ntype goBoolFlag interface {\n\tgoflag.Value\n\tIsBoolFlag() bool\n}\n\nfunc wrapFlagValue(v goflag.Value) Value {\n\t// If the flag.Value happens to also be a pflag.Value, just use it directly.\n\tif pv, ok := v.(Value); ok {\n\t\treturn pv\n\t}\n\n\tpv := &flagValueWrapper{\n\t\tinner: v,\n\t}\n\n\tt := reflect.TypeOf(v)\n\tif t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr {\n\t\tt = t.Elem()\n\t}\n\n\tpv.flagType = strings.TrimSuffix(t.Name(), \"Value\")\n\treturn pv\n}\n\nfunc (v *flagValueWrapper) String() string {\n\treturn v.inner.String()\n}\n\nfunc (v *flagValueWrapper) Set(s string) error {\n\treturn v.inner.Set(s)\n}\n\nfunc (v *flagValueWrapper) Type() string {\n\treturn v.flagType\n}\n\n// PFlagFromGoFlag will return a *pflag.Flag given a *flag.Flag\n// If the *flag.Flag.Name was a single character (ex: `v`) it will be accessiblei\n// with both `-v` and `--v` in flags. If the golang flag was more than a single\n// character (ex: `verbose`) it will only be accessible via `--verbose`\nfunc PFlagFromGoFlag(goflag *goflag.Flag) *Flag {\n\t// Remember the default value as a string; it won't change.\n\tflag := &Flag{\n\t\tName: goflag.Name,\n\t\tUsage: goflag.Usage,\n\t\tValue: wrapFlagValue(goflag.Value),\n\t\t// Looks like golang flags don't set DefValue correctly :-(\n\t\t//DefValue: goflag.DefValue,\n\t\tDefValue: goflag.Value.String(),\n\t}\n\t// Ex: if the golang flag was -v, allow both -v and --v to work\n\tif len(flag.Name) == 1 {\n\t\tflag.Shorthand = flag.Name\n\t}\n\tif fv, ok := goflag.Value.(goBoolFlag); ok && fv.IsBoolFlag() {\n\t\tflag.NoOptDefVal = \"true\"\n\t}\n\treturn flag\n}\n\n// AddGoFlag will add the given *flag.Flag to the pflag.FlagSet\nfunc (f *FlagSet) AddGoFlag(goflag *goflag.Flag) {\n\tif f.Lookup(goflag.Name) != nil {\n\t\treturn\n\t}\n\tnewflag := PFlagFromGoFlag(goflag)\n\tf.AddFlag(newflag)\n}\n\n// AddGoFlagSet will add the given *flag.FlagSet to the pflag.FlagSet\nfunc (f *FlagSet) AddGoFlagSet(newSet *goflag.FlagSet) {\n\tif newSet == nil {\n\t\treturn\n\t}\n\tnewSet.VisitAll(func(goflag *goflag.Flag) {\n\t\tf.AddGoFlag(goflag)\n\t})\n\tif f.addedGoFlagSets == nil {\n\t\tf.addedGoFlagSets = make([]*goflag.FlagSet, 0)\n\t}\n\tf.addedGoFlagSets = append(f.addedGoFlagSets, newSet)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- int Value\ntype intValue int\n\nfunc newIntValue(val int, p *int) *intValue {\n\t*p = val\n\treturn (*intValue)(p)\n}\n\nfunc (i *intValue) Set(s string) error {\n\tv, err := strconv.ParseInt(s, 0, 64)\n\t*i = intValue(v)\n\treturn err\n}\n\nfunc (i *intValue) Type() string {\n\treturn \"int\"\n}\n\nfunc (i *intValue) String() string { return strconv.Itoa(int(*i)) }\n\nfunc intConv(sval string) (interface{}, error) {\n\treturn strconv.Atoi(sval)\n}\n\n// GetInt return the int value of a flag with the given name\nfunc (f *FlagSet) GetInt(name string) (int, error) {\n\tval, err := f.getFlagType(name, \"int\", intConv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int), nil\n}\n\n// IntVar defines an int flag with specified name, default value, and usage string.\n// The argument p points to an int variable in which to store the value of the flag.\nfunc (f *FlagSet) IntVar(p *int, name string, value int, usage string) {\n\tf.VarP(newIntValue(value, p), name, \"\", usage)\n}\n\n// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IntVarP(p *int, name, shorthand string, value int, usage string) {\n\tf.VarP(newIntValue(value, p), name, shorthand, usage)\n}\n\n// IntVar defines an int flag with specified name, default value, and usage string.\n// The argument p points to an int variable in which to store the value of the flag.\nfunc IntVar(p *int, name string, value int, usage string) {\n\tCommandLine.VarP(newIntValue(value, p), name, \"\", usage)\n}\n\n// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IntVarP(p *int, name, shorthand string, value int, usage string) {\n\tCommandLine.VarP(newIntValue(value, p), name, shorthand, usage)\n}\n\n// Int defines an int flag with specified name, default value, and usage string.\n// The return value is the address of an int variable that stores the value of the flag.\nfunc (f *FlagSet) Int(name string, value int, usage string) *int {\n\tp := new(int)\n\tf.IntVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IntP(name, shorthand string, value int, usage string) *int {\n\tp := new(int)\n\tf.IntVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Int defines an int flag with specified name, default value, and usage string.\n// The return value is the address of an int variable that stores the value of the flag.\nfunc Int(name string, value int, usage string) *int {\n\treturn CommandLine.IntP(name, \"\", value, usage)\n}\n\n// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.\nfunc IntP(name, shorthand string, value int, usage string) *int {\n\treturn CommandLine.IntP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int16.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- int16 Value\ntype int16Value int16\n\nfunc newInt16Value(val int16, p *int16) *int16Value {\n\t*p = val\n\treturn (*int16Value)(p)\n}\n\nfunc (i *int16Value) Set(s string) error {\n\tv, err := strconv.ParseInt(s, 0, 16)\n\t*i = int16Value(v)\n\treturn err\n}\n\nfunc (i *int16Value) Type() string {\n\treturn \"int16\"\n}\n\nfunc (i *int16Value) String() string { return strconv.FormatInt(int64(*i), 10) }\n\nfunc int16Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseInt(sval, 0, 16)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn int16(v), nil\n}\n\n// GetInt16 returns the int16 value of a flag with the given name\nfunc (f *FlagSet) GetInt16(name string) (int16, error) {\n\tval, err := f.getFlagType(name, \"int16\", int16Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int16), nil\n}\n\n// Int16Var defines an int16 flag with specified name, default value, and usage string.\n// The argument p points to an int16 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int16Var(p *int16, name string, value int16, usage string) {\n\tf.VarP(newInt16Value(value, p), name, \"\", usage)\n}\n\n// Int16VarP is like Int16Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int16VarP(p *int16, name, shorthand string, value int16, usage string) {\n\tf.VarP(newInt16Value(value, p), name, shorthand, usage)\n}\n\n// Int16Var defines an int16 flag with specified name, default value, and usage string.\n// The argument p points to an int16 variable in which to store the value of the flag.\nfunc Int16Var(p *int16, name string, value int16, usage string) {\n\tCommandLine.VarP(newInt16Value(value, p), name, \"\", usage)\n}\n\n// Int16VarP is like Int16Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Int16VarP(p *int16, name, shorthand string, value int16, usage string) {\n\tCommandLine.VarP(newInt16Value(value, p), name, shorthand, usage)\n}\n\n// Int16 defines an int16 flag with specified name, default value, and usage string.\n// The return value is the address of an int16 variable that stores the value of the flag.\nfunc (f *FlagSet) Int16(name string, value int16, usage string) *int16 {\n\tp := new(int16)\n\tf.Int16VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Int16P is like Int16, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int16P(name, shorthand string, value int16, usage string) *int16 {\n\tp := new(int16)\n\tf.Int16VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Int16 defines an int16 flag with specified name, default value, and usage string.\n// The return value is the address of an int16 variable that stores the value of the flag.\nfunc Int16(name string, value int16, usage string) *int16 {\n\treturn CommandLine.Int16P(name, \"\", value, usage)\n}\n\n// Int16P is like Int16, but accepts a shorthand letter that can be used after a single dash.\nfunc Int16P(name, shorthand string, value int16, usage string) *int16 {\n\treturn CommandLine.Int16P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int32.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- int32 Value\ntype int32Value int32\n\nfunc newInt32Value(val int32, p *int32) *int32Value {\n\t*p = val\n\treturn (*int32Value)(p)\n}\n\nfunc (i *int32Value) Set(s string) error {\n\tv, err := strconv.ParseInt(s, 0, 32)\n\t*i = int32Value(v)\n\treturn err\n}\n\nfunc (i *int32Value) Type() string {\n\treturn \"int32\"\n}\n\nfunc (i *int32Value) String() string { return strconv.FormatInt(int64(*i), 10) }\n\nfunc int32Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseInt(sval, 0, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn int32(v), nil\n}\n\n// GetInt32 return the int32 value of a flag with the given name\nfunc (f *FlagSet) GetInt32(name string) (int32, error) {\n\tval, err := f.getFlagType(name, \"int32\", int32Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int32), nil\n}\n\n// Int32Var defines an int32 flag with specified name, default value, and usage string.\n// The argument p points to an int32 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int32Var(p *int32, name string, value int32, usage string) {\n\tf.VarP(newInt32Value(value, p), name, \"\", usage)\n}\n\n// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int32VarP(p *int32, name, shorthand string, value int32, usage string) {\n\tf.VarP(newInt32Value(value, p), name, shorthand, usage)\n}\n\n// Int32Var defines an int32 flag with specified name, default value, and usage string.\n// The argument p points to an int32 variable in which to store the value of the flag.\nfunc Int32Var(p *int32, name string, value int32, usage string) {\n\tCommandLine.VarP(newInt32Value(value, p), name, \"\", usage)\n}\n\n// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Int32VarP(p *int32, name, shorthand string, value int32, usage string) {\n\tCommandLine.VarP(newInt32Value(value, p), name, shorthand, usage)\n}\n\n// Int32 defines an int32 flag with specified name, default value, and usage string.\n// The return value is the address of an int32 variable that stores the value of the flag.\nfunc (f *FlagSet) Int32(name string, value int32, usage string) *int32 {\n\tp := new(int32)\n\tf.Int32VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int32P(name, shorthand string, value int32, usage string) *int32 {\n\tp := new(int32)\n\tf.Int32VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Int32 defines an int32 flag with specified name, default value, and usage string.\n// The return value is the address of an int32 variable that stores the value of the flag.\nfunc Int32(name string, value int32, usage string) *int32 {\n\treturn CommandLine.Int32P(name, \"\", value, usage)\n}\n\n// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.\nfunc Int32P(name, shorthand string, value int32, usage string) *int32 {\n\treturn CommandLine.Int32P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int32_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- int32Slice Value\ntype int32SliceValue struct {\n\tvalue *[]int32\n\tchanged bool\n}\n\nfunc newInt32SliceValue(val []int32, p *[]int32) *int32SliceValue {\n\tisv := new(int32SliceValue)\n\tisv.value = p\n\t*isv.value = val\n\treturn isv\n}\n\nfunc (s *int32SliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]int32, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tvar temp64 int64\n\t\ttemp64, err = strconv.ParseInt(d, 0, 32)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tout[i] = int32(temp64)\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *int32SliceValue) Type() string {\n\treturn \"int32Slice\"\n}\n\nfunc (s *int32SliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%d\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *int32SliceValue) fromString(val string) (int32, error) {\n\tt64, err := strconv.ParseInt(val, 0, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn int32(t64), nil\n}\n\nfunc (s *int32SliceValue) toString(val int32) string {\n\treturn fmt.Sprintf(\"%d\", val)\n}\n\nfunc (s *int32SliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *int32SliceValue) Replace(val []string) error {\n\tout := make([]int32, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *int32SliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc int32SliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []int32{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]int32, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tvar temp64 int64\n\t\ttemp64, err = strconv.ParseInt(d, 0, 32)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tout[i] = int32(temp64)\n\n\t}\n\treturn out, nil\n}\n\n// GetInt32Slice return the []int32 value of a flag with the given name\nfunc (f *FlagSet) GetInt32Slice(name string) ([]int32, error) {\n\tval, err := f.getFlagType(name, \"int32Slice\", int32SliceConv)\n\tif err != nil {\n\t\treturn []int32{}, err\n\t}\n\treturn val.([]int32), nil\n}\n\n// Int32SliceVar defines a int32Slice flag with specified name, default value, and usage string.\n// The argument p points to a []int32 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int32SliceVar(p *[]int32, name string, value []int32, usage string) {\n\tf.VarP(newInt32SliceValue(value, p), name, \"\", usage)\n}\n\n// Int32SliceVarP is like Int32SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int32SliceVarP(p *[]int32, name, shorthand string, value []int32, usage string) {\n\tf.VarP(newInt32SliceValue(value, p), name, shorthand, usage)\n}\n\n// Int32SliceVar defines a int32[] flag with specified name, default value, and usage string.\n// The argument p points to a int32[] variable in which to store the value of the flag.\nfunc Int32SliceVar(p *[]int32, name string, value []int32, usage string) {\n\tCommandLine.VarP(newInt32SliceValue(value, p), name, \"\", usage)\n}\n\n// Int32SliceVarP is like Int32SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc Int32SliceVarP(p *[]int32, name, shorthand string, value []int32, usage string) {\n\tCommandLine.VarP(newInt32SliceValue(value, p), name, shorthand, usage)\n}\n\n// Int32Slice defines a []int32 flag with specified name, default value, and usage string.\n// The return value is the address of a []int32 variable that stores the value of the flag.\nfunc (f *FlagSet) Int32Slice(name string, value []int32, usage string) *[]int32 {\n\tp := []int32{}\n\tf.Int32SliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// Int32SliceP is like Int32Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int32SliceP(name, shorthand string, value []int32, usage string) *[]int32 {\n\tp := []int32{}\n\tf.Int32SliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// Int32Slice defines a []int32 flag with specified name, default value, and usage string.\n// The return value is the address of a []int32 variable that stores the value of the flag.\nfunc Int32Slice(name string, value []int32, usage string) *[]int32 {\n\treturn CommandLine.Int32SliceP(name, \"\", value, usage)\n}\n\n// Int32SliceP is like Int32Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc Int32SliceP(name, shorthand string, value []int32, usage string) *[]int32 {\n\treturn CommandLine.Int32SliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int64.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- int64 Value\ntype int64Value int64\n\nfunc newInt64Value(val int64, p *int64) *int64Value {\n\t*p = val\n\treturn (*int64Value)(p)\n}\n\nfunc (i *int64Value) Set(s string) error {\n\tv, err := strconv.ParseInt(s, 0, 64)\n\t*i = int64Value(v)\n\treturn err\n}\n\nfunc (i *int64Value) Type() string {\n\treturn \"int64\"\n}\n\nfunc (i *int64Value) String() string { return strconv.FormatInt(int64(*i), 10) }\n\nfunc int64Conv(sval string) (interface{}, error) {\n\treturn strconv.ParseInt(sval, 0, 64)\n}\n\n// GetInt64 return the int64 value of a flag with the given name\nfunc (f *FlagSet) GetInt64(name string) (int64, error) {\n\tval, err := f.getFlagType(name, \"int64\", int64Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int64), nil\n}\n\n// Int64Var defines an int64 flag with specified name, default value, and usage string.\n// The argument p points to an int64 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) {\n\tf.VarP(newInt64Value(value, p), name, \"\", usage)\n}\n\n// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int64VarP(p *int64, name, shorthand string, value int64, usage string) {\n\tf.VarP(newInt64Value(value, p), name, shorthand, usage)\n}\n\n// Int64Var defines an int64 flag with specified name, default value, and usage string.\n// The argument p points to an int64 variable in which to store the value of the flag.\nfunc Int64Var(p *int64, name string, value int64, usage string) {\n\tCommandLine.VarP(newInt64Value(value, p), name, \"\", usage)\n}\n\n// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Int64VarP(p *int64, name, shorthand string, value int64, usage string) {\n\tCommandLine.VarP(newInt64Value(value, p), name, shorthand, usage)\n}\n\n// Int64 defines an int64 flag with specified name, default value, and usage string.\n// The return value is the address of an int64 variable that stores the value of the flag.\nfunc (f *FlagSet) Int64(name string, value int64, usage string) *int64 {\n\tp := new(int64)\n\tf.Int64VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int64P(name, shorthand string, value int64, usage string) *int64 {\n\tp := new(int64)\n\tf.Int64VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Int64 defines an int64 flag with specified name, default value, and usage string.\n// The return value is the address of an int64 variable that stores the value of the flag.\nfunc Int64(name string, value int64, usage string) *int64 {\n\treturn CommandLine.Int64P(name, \"\", value, usage)\n}\n\n// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.\nfunc Int64P(name, shorthand string, value int64, usage string) *int64 {\n\treturn CommandLine.Int64P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int64_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- int64Slice Value\ntype int64SliceValue struct {\n\tvalue *[]int64\n\tchanged bool\n}\n\nfunc newInt64SliceValue(val []int64, p *[]int64) *int64SliceValue {\n\tisv := new(int64SliceValue)\n\tisv.value = p\n\t*isv.value = val\n\treturn isv\n}\n\nfunc (s *int64SliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]int64, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.ParseInt(d, 0, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *int64SliceValue) Type() string {\n\treturn \"int64Slice\"\n}\n\nfunc (s *int64SliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%d\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *int64SliceValue) fromString(val string) (int64, error) {\n\treturn strconv.ParseInt(val, 0, 64)\n}\n\nfunc (s *int64SliceValue) toString(val int64) string {\n\treturn fmt.Sprintf(\"%d\", val)\n}\n\nfunc (s *int64SliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *int64SliceValue) Replace(val []string) error {\n\tout := make([]int64, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *int64SliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc int64SliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []int64{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]int64, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.ParseInt(d, 0, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t}\n\treturn out, nil\n}\n\n// GetInt64Slice return the []int64 value of a flag with the given name\nfunc (f *FlagSet) GetInt64Slice(name string) ([]int64, error) {\n\tval, err := f.getFlagType(name, \"int64Slice\", int64SliceConv)\n\tif err != nil {\n\t\treturn []int64{}, err\n\t}\n\treturn val.([]int64), nil\n}\n\n// Int64SliceVar defines a int64Slice flag with specified name, default value, and usage string.\n// The argument p points to a []int64 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int64SliceVar(p *[]int64, name string, value []int64, usage string) {\n\tf.VarP(newInt64SliceValue(value, p), name, \"\", usage)\n}\n\n// Int64SliceVarP is like Int64SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int64SliceVarP(p *[]int64, name, shorthand string, value []int64, usage string) {\n\tf.VarP(newInt64SliceValue(value, p), name, shorthand, usage)\n}\n\n// Int64SliceVar defines a int64[] flag with specified name, default value, and usage string.\n// The argument p points to a int64[] variable in which to store the value of the flag.\nfunc Int64SliceVar(p *[]int64, name string, value []int64, usage string) {\n\tCommandLine.VarP(newInt64SliceValue(value, p), name, \"\", usage)\n}\n\n// Int64SliceVarP is like Int64SliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc Int64SliceVarP(p *[]int64, name, shorthand string, value []int64, usage string) {\n\tCommandLine.VarP(newInt64SliceValue(value, p), name, shorthand, usage)\n}\n\n// Int64Slice defines a []int64 flag with specified name, default value, and usage string.\n// The return value is the address of a []int64 variable that stores the value of the flag.\nfunc (f *FlagSet) Int64Slice(name string, value []int64, usage string) *[]int64 {\n\tp := []int64{}\n\tf.Int64SliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// Int64SliceP is like Int64Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int64SliceP(name, shorthand string, value []int64, usage string) *[]int64 {\n\tp := []int64{}\n\tf.Int64SliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// Int64Slice defines a []int64 flag with specified name, default value, and usage string.\n// The return value is the address of a []int64 variable that stores the value of the flag.\nfunc Int64Slice(name string, value []int64, usage string) *[]int64 {\n\treturn CommandLine.Int64SliceP(name, \"\", value, usage)\n}\n\n// Int64SliceP is like Int64Slice, but accepts a shorthand letter that can be used after a single dash.\nfunc Int64SliceP(name, shorthand string, value []int64, usage string) *[]int64 {\n\treturn CommandLine.Int64SliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int8.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- int8 Value\ntype int8Value int8\n\nfunc newInt8Value(val int8, p *int8) *int8Value {\n\t*p = val\n\treturn (*int8Value)(p)\n}\n\nfunc (i *int8Value) Set(s string) error {\n\tv, err := strconv.ParseInt(s, 0, 8)\n\t*i = int8Value(v)\n\treturn err\n}\n\nfunc (i *int8Value) Type() string {\n\treturn \"int8\"\n}\n\nfunc (i *int8Value) String() string { return strconv.FormatInt(int64(*i), 10) }\n\nfunc int8Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseInt(sval, 0, 8)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn int8(v), nil\n}\n\n// GetInt8 return the int8 value of a flag with the given name\nfunc (f *FlagSet) GetInt8(name string) (int8, error) {\n\tval, err := f.getFlagType(name, \"int8\", int8Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(int8), nil\n}\n\n// Int8Var defines an int8 flag with specified name, default value, and usage string.\n// The argument p points to an int8 variable in which to store the value of the flag.\nfunc (f *FlagSet) Int8Var(p *int8, name string, value int8, usage string) {\n\tf.VarP(newInt8Value(value, p), name, \"\", usage)\n}\n\n// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int8VarP(p *int8, name, shorthand string, value int8, usage string) {\n\tf.VarP(newInt8Value(value, p), name, shorthand, usage)\n}\n\n// Int8Var defines an int8 flag with specified name, default value, and usage string.\n// The argument p points to an int8 variable in which to store the value of the flag.\nfunc Int8Var(p *int8, name string, value int8, usage string) {\n\tCommandLine.VarP(newInt8Value(value, p), name, \"\", usage)\n}\n\n// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Int8VarP(p *int8, name, shorthand string, value int8, usage string) {\n\tCommandLine.VarP(newInt8Value(value, p), name, shorthand, usage)\n}\n\n// Int8 defines an int8 flag with specified name, default value, and usage string.\n// The return value is the address of an int8 variable that stores the value of the flag.\nfunc (f *FlagSet) Int8(name string, value int8, usage string) *int8 {\n\tp := new(int8)\n\tf.Int8VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Int8P(name, shorthand string, value int8, usage string) *int8 {\n\tp := new(int8)\n\tf.Int8VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Int8 defines an int8 flag with specified name, default value, and usage string.\n// The return value is the address of an int8 variable that stores the value of the flag.\nfunc Int8(name string, value int8, usage string) *int8 {\n\treturn CommandLine.Int8P(name, \"\", value, usage)\n}\n\n// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.\nfunc Int8P(name, shorthand string, value int8, usage string) *int8 {\n\treturn CommandLine.Int8P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/int_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- intSlice Value\ntype intSliceValue struct {\n\tvalue *[]int\n\tchanged bool\n}\n\nfunc newIntSliceValue(val []int, p *[]int) *intSliceValue {\n\tisv := new(intSliceValue)\n\tisv.value = p\n\t*isv.value = val\n\treturn isv\n}\n\nfunc (s *intSliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]int, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.Atoi(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *intSliceValue) Type() string {\n\treturn \"intSlice\"\n}\n\nfunc (s *intSliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%d\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *intSliceValue) Append(val string) error {\n\ti, err := strconv.Atoi(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *intSliceValue) Replace(val []string) error {\n\tout := make([]int, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = strconv.Atoi(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *intSliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = strconv.Itoa(d)\n\t}\n\treturn out\n}\n\nfunc intSliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []int{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]int, len(ss))\n\tfor i, d := range ss {\n\t\tvar err error\n\t\tout[i], err = strconv.Atoi(d)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t}\n\treturn out, nil\n}\n\n// GetIntSlice return the []int value of a flag with the given name\nfunc (f *FlagSet) GetIntSlice(name string) ([]int, error) {\n\tval, err := f.getFlagType(name, \"intSlice\", intSliceConv)\n\tif err != nil {\n\t\treturn []int{}, err\n\t}\n\treturn val.([]int), nil\n}\n\n// IntSliceVar defines a intSlice flag with specified name, default value, and usage string.\n// The argument p points to a []int variable in which to store the value of the flag.\nfunc (f *FlagSet) IntSliceVar(p *[]int, name string, value []int, usage string) {\n\tf.VarP(newIntSliceValue(value, p), name, \"\", usage)\n}\n\n// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {\n\tf.VarP(newIntSliceValue(value, p), name, shorthand, usage)\n}\n\n// IntSliceVar defines a int[] flag with specified name, default value, and usage string.\n// The argument p points to a int[] variable in which to store the value of the flag.\nfunc IntSliceVar(p *[]int, name string, value []int, usage string) {\n\tCommandLine.VarP(newIntSliceValue(value, p), name, \"\", usage)\n}\n\n// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {\n\tCommandLine.VarP(newIntSliceValue(value, p), name, shorthand, usage)\n}\n\n// IntSlice defines a []int flag with specified name, default value, and usage string.\n// The return value is the address of a []int variable that stores the value of the flag.\nfunc (f *FlagSet) IntSlice(name string, value []int, usage string) *[]int {\n\tp := []int{}\n\tf.IntSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IntSliceP(name, shorthand string, value []int, usage string) *[]int {\n\tp := []int{}\n\tf.IntSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// IntSlice defines a []int flag with specified name, default value, and usage string.\n// The return value is the address of a []int variable that stores the value of the flag.\nfunc IntSlice(name string, value []int, usage string) *[]int {\n\treturn CommandLine.IntSliceP(name, \"\", value, usage)\n}\n\n// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc IntSliceP(name, shorthand string, value []int, usage string) *[]int {\n\treturn CommandLine.IntSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/ip.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"net\"\n\t\"strings\"\n)\n\n// -- net.IP value\ntype ipValue net.IP\n\nfunc newIPValue(val net.IP, p *net.IP) *ipValue {\n\t*p = val\n\treturn (*ipValue)(p)\n}\n\nfunc (i *ipValue) String() string { return net.IP(*i).String() }\nfunc (i *ipValue) Set(s string) error {\n\tip := net.ParseIP(strings.TrimSpace(s))\n\tif ip == nil {\n\t\treturn fmt.Errorf(\"failed to parse IP: %q\", s)\n\t}\n\t*i = ipValue(ip)\n\treturn nil\n}\n\nfunc (i *ipValue) Type() string {\n\treturn \"ip\"\n}\n\nfunc ipConv(sval string) (interface{}, error) {\n\tip := net.ParseIP(sval)\n\tif ip != nil {\n\t\treturn ip, nil\n\t}\n\treturn nil, fmt.Errorf(\"invalid string being converted to IP address: %s\", sval)\n}\n\n// GetIP return the net.IP value of a flag with the given name\nfunc (f *FlagSet) GetIP(name string) (net.IP, error) {\n\tval, err := f.getFlagType(name, \"ip\", ipConv)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn val.(net.IP), nil\n}\n\n// IPVar defines an net.IP flag with specified name, default value, and usage string.\n// The argument p points to an net.IP variable in which to store the value of the flag.\nfunc (f *FlagSet) IPVar(p *net.IP, name string, value net.IP, usage string) {\n\tf.VarP(newIPValue(value, p), name, \"\", usage)\n}\n\n// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {\n\tf.VarP(newIPValue(value, p), name, shorthand, usage)\n}\n\n// IPVar defines an net.IP flag with specified name, default value, and usage string.\n// The argument p points to an net.IP variable in which to store the value of the flag.\nfunc IPVar(p *net.IP, name string, value net.IP, usage string) {\n\tCommandLine.VarP(newIPValue(value, p), name, \"\", usage)\n}\n\n// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {\n\tCommandLine.VarP(newIPValue(value, p), name, shorthand, usage)\n}\n\n// IP defines an net.IP flag with specified name, default value, and usage string.\n// The return value is the address of an net.IP variable that stores the value of the flag.\nfunc (f *FlagSet) IP(name string, value net.IP, usage string) *net.IP {\n\tp := new(net.IP)\n\tf.IPVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPP(name, shorthand string, value net.IP, usage string) *net.IP {\n\tp := new(net.IP)\n\tf.IPVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// IP defines an net.IP flag with specified name, default value, and usage string.\n// The return value is the address of an net.IP variable that stores the value of the flag.\nfunc IP(name string, value net.IP, usage string) *net.IP {\n\treturn CommandLine.IPP(name, \"\", value, usage)\n}\n\n// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.\nfunc IPP(name, shorthand string, value net.IP, usage string) *net.IP {\n\treturn CommandLine.IPP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/ip_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"strings\"\n)\n\n// -- ipSlice Value\ntype ipSliceValue struct {\n\tvalue *[]net.IP\n\tchanged bool\n}\n\nfunc newIPSliceValue(val []net.IP, p *[]net.IP) *ipSliceValue {\n\tipsv := new(ipSliceValue)\n\tipsv.value = p\n\t*ipsv.value = val\n\treturn ipsv\n}\n\n// Set converts, and assigns, the comma-separated IP argument string representation as the []net.IP value of this flag.\n// If Set is called on a flag that already has a []net.IP assigned, the newly converted values will be appended.\nfunc (s *ipSliceValue) Set(val string) error {\n\n\t// remove all quote characters\n\trmQuote := strings.NewReplacer(`\"`, \"\", `'`, \"\", \"`\", \"\")\n\n\t// read flag arguments with CSV parser\n\tipStrSlice, err := readAsCSV(rmQuote.Replace(val))\n\tif err != nil && err != io.EOF {\n\t\treturn err\n\t}\n\n\t// parse ip values into slice\n\tout := make([]net.IP, 0, len(ipStrSlice))\n\tfor _, ipStr := range ipStrSlice {\n\t\tip := net.ParseIP(strings.TrimSpace(ipStr))\n\t\tif ip == nil {\n\t\t\treturn fmt.Errorf(\"invalid string being converted to IP address: %s\", ipStr)\n\t\t}\n\t\tout = append(out, ip)\n\t}\n\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\n\ts.changed = true\n\n\treturn nil\n}\n\n// Type returns a string that uniquely represents this flag's type.\nfunc (s *ipSliceValue) Type() string {\n\treturn \"ipSlice\"\n}\n\n// String defines a \"native\" format for this net.IP slice flag value.\nfunc (s *ipSliceValue) String() string {\n\n\tipStrSlice := make([]string, len(*s.value))\n\tfor i, ip := range *s.value {\n\t\tipStrSlice[i] = ip.String()\n\t}\n\n\tout, _ := writeAsCSV(ipStrSlice)\n\n\treturn \"[\" + out + \"]\"\n}\n\nfunc (s *ipSliceValue) fromString(val string) (net.IP, error) {\n\treturn net.ParseIP(strings.TrimSpace(val)), nil\n}\n\nfunc (s *ipSliceValue) toString(val net.IP) string {\n\treturn val.String()\n}\n\nfunc (s *ipSliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *ipSliceValue) Replace(val []string) error {\n\tout := make([]net.IP, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *ipSliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc ipSliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []net.IP{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]net.IP, len(ss))\n\tfor i, sval := range ss {\n\t\tip := net.ParseIP(strings.TrimSpace(sval))\n\t\tif ip == nil {\n\t\t\treturn nil, fmt.Errorf(\"invalid string being converted to IP address: %s\", sval)\n\t\t}\n\t\tout[i] = ip\n\t}\n\treturn out, nil\n}\n\n// GetIPSlice returns the []net.IP value of a flag with the given name\nfunc (f *FlagSet) GetIPSlice(name string) ([]net.IP, error) {\n\tval, err := f.getFlagType(name, \"ipSlice\", ipSliceConv)\n\tif err != nil {\n\t\treturn []net.IP{}, err\n\t}\n\treturn val.([]net.IP), nil\n}\n\n// IPSliceVar defines a ipSlice flag with specified name, default value, and usage string.\n// The argument p points to a []net.IP variable in which to store the value of the flag.\nfunc (f *FlagSet) IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {\n\tf.VarP(newIPSliceValue(value, p), name, \"\", usage)\n}\n\n// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {\n\tf.VarP(newIPSliceValue(value, p), name, shorthand, usage)\n}\n\n// IPSliceVar defines a []net.IP flag with specified name, default value, and usage string.\n// The argument p points to a []net.IP variable in which to store the value of the flag.\nfunc IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {\n\tCommandLine.VarP(newIPSliceValue(value, p), name, \"\", usage)\n}\n\n// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {\n\tCommandLine.VarP(newIPSliceValue(value, p), name, shorthand, usage)\n}\n\n// IPSlice defines a []net.IP flag with specified name, default value, and usage string.\n// The return value is the address of a []net.IP variable that stores the value of that flag.\nfunc (f *FlagSet) IPSlice(name string, value []net.IP, usage string) *[]net.IP {\n\tp := []net.IP{}\n\tf.IPSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {\n\tp := []net.IP{}\n\tf.IPSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// IPSlice defines a []net.IP flag with specified name, default value, and usage string.\n// The return value is the address of a []net.IP variable that stores the value of the flag.\nfunc IPSlice(name string, value []net.IP, usage string) *[]net.IP {\n\treturn CommandLine.IPSliceP(name, \"\", value, usage)\n}\n\n// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {\n\treturn CommandLine.IPSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/ipmask.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"net\"\n\t\"strconv\"\n)\n\n// -- net.IPMask value\ntype ipMaskValue net.IPMask\n\nfunc newIPMaskValue(val net.IPMask, p *net.IPMask) *ipMaskValue {\n\t*p = val\n\treturn (*ipMaskValue)(p)\n}\n\nfunc (i *ipMaskValue) String() string { return net.IPMask(*i).String() }\nfunc (i *ipMaskValue) Set(s string) error {\n\tip := ParseIPv4Mask(s)\n\tif ip == nil {\n\t\treturn fmt.Errorf(\"failed to parse IP mask: %q\", s)\n\t}\n\t*i = ipMaskValue(ip)\n\treturn nil\n}\n\nfunc (i *ipMaskValue) Type() string {\n\treturn \"ipMask\"\n}\n\n// ParseIPv4Mask written in IP form (e.g. 255.255.255.0).\n// This function should really belong to the net package.\nfunc ParseIPv4Mask(s string) net.IPMask {\n\tmask := net.ParseIP(s)\n\tif mask == nil {\n\t\tif len(s) != 8 {\n\t\t\treturn nil\n\t\t}\n\t\t// net.IPMask.String() actually outputs things like ffffff00\n\t\t// so write a horrible parser for that as well :-(\n\t\tm := []int{}\n\t\tfor i := 0; i < 4; i++ {\n\t\t\tb := \"0x\" + s[2*i:2*i+2]\n\t\t\td, err := strconv.ParseInt(b, 0, 0)\n\t\t\tif err != nil {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\tm = append(m, int(d))\n\t\t}\n\t\ts := fmt.Sprintf(\"%d.%d.%d.%d\", m[0], m[1], m[2], m[3])\n\t\tmask = net.ParseIP(s)\n\t\tif mask == nil {\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn net.IPv4Mask(mask[12], mask[13], mask[14], mask[15])\n}\n\nfunc parseIPv4Mask(sval string) (interface{}, error) {\n\tmask := ParseIPv4Mask(sval)\n\tif mask == nil {\n\t\treturn nil, fmt.Errorf(\"unable to parse %s as net.IPMask\", sval)\n\t}\n\treturn mask, nil\n}\n\n// GetIPv4Mask return the net.IPv4Mask value of a flag with the given name\nfunc (f *FlagSet) GetIPv4Mask(name string) (net.IPMask, error) {\n\tval, err := f.getFlagType(name, \"ipMask\", parseIPv4Mask)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn val.(net.IPMask), nil\n}\n\n// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.\n// The argument p points to an net.IPMask variable in which to store the value of the flag.\nfunc (f *FlagSet) IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {\n\tf.VarP(newIPMaskValue(value, p), name, \"\", usage)\n}\n\n// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {\n\tf.VarP(newIPMaskValue(value, p), name, shorthand, usage)\n}\n\n// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.\n// The argument p points to an net.IPMask variable in which to store the value of the flag.\nfunc IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {\n\tCommandLine.VarP(newIPMaskValue(value, p), name, \"\", usage)\n}\n\n// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {\n\tCommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage)\n}\n\n// IPMask defines an net.IPMask flag with specified name, default value, and usage string.\n// The return value is the address of an net.IPMask variable that stores the value of the flag.\nfunc (f *FlagSet) IPMask(name string, value net.IPMask, usage string) *net.IPMask {\n\tp := new(net.IPMask)\n\tf.IPMaskVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// IPMaskP is like IPMask, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {\n\tp := new(net.IPMask)\n\tf.IPMaskVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// IPMask defines an net.IPMask flag with specified name, default value, and usage string.\n// The return value is the address of an net.IPMask variable that stores the value of the flag.\nfunc IPMask(name string, value net.IPMask, usage string) *net.IPMask {\n\treturn CommandLine.IPMaskP(name, \"\", value, usage)\n}\n\n// IPMaskP is like IP, but accepts a shorthand letter that can be used after a single dash.\nfunc IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {\n\treturn CommandLine.IPMaskP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/ipnet.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"net\"\n\t\"strings\"\n)\n\n// IPNet adapts net.IPNet for use as a flag.\ntype ipNetValue net.IPNet\n\nfunc (ipnet ipNetValue) String() string {\n\tn := net.IPNet(ipnet)\n\treturn n.String()\n}\n\nfunc (ipnet *ipNetValue) Set(value string) error {\n\t_, n, err := net.ParseCIDR(strings.TrimSpace(value))\n\tif err != nil {\n\t\treturn err\n\t}\n\t*ipnet = ipNetValue(*n)\n\treturn nil\n}\n\nfunc (*ipNetValue) Type() string {\n\treturn \"ipNet\"\n}\n\nfunc newIPNetValue(val net.IPNet, p *net.IPNet) *ipNetValue {\n\t*p = val\n\treturn (*ipNetValue)(p)\n}\n\nfunc ipNetConv(sval string) (interface{}, error) {\n\t_, n, err := net.ParseCIDR(strings.TrimSpace(sval))\n\tif err == nil {\n\t\treturn *n, nil\n\t}\n\treturn nil, fmt.Errorf(\"invalid string being converted to IPNet: %s\", sval)\n}\n\n// GetIPNet return the net.IPNet value of a flag with the given name\nfunc (f *FlagSet) GetIPNet(name string) (net.IPNet, error) {\n\tval, err := f.getFlagType(name, \"ipNet\", ipNetConv)\n\tif err != nil {\n\t\treturn net.IPNet{}, err\n\t}\n\treturn val.(net.IPNet), nil\n}\n\n// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string.\n// The argument p points to an net.IPNet variable in which to store the value of the flag.\nfunc (f *FlagSet) IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) {\n\tf.VarP(newIPNetValue(value, p), name, \"\", usage)\n}\n\n// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {\n\tf.VarP(newIPNetValue(value, p), name, shorthand, usage)\n}\n\n// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string.\n// The argument p points to an net.IPNet variable in which to store the value of the flag.\nfunc IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) {\n\tCommandLine.VarP(newIPNetValue(value, p), name, \"\", usage)\n}\n\n// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.\nfunc IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {\n\tCommandLine.VarP(newIPNetValue(value, p), name, shorthand, usage)\n}\n\n// IPNet defines an net.IPNet flag with specified name, default value, and usage string.\n// The return value is the address of an net.IPNet variable that stores the value of the flag.\nfunc (f *FlagSet) IPNet(name string, value net.IPNet, usage string) *net.IPNet {\n\tp := new(net.IPNet)\n\tf.IPNetVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {\n\tp := new(net.IPNet)\n\tf.IPNetVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// IPNet defines an net.IPNet flag with specified name, default value, and usage string.\n// The return value is the address of an net.IPNet variable that stores the value of the flag.\nfunc IPNet(name string, value net.IPNet, usage string) *net.IPNet {\n\treturn CommandLine.IPNetP(name, \"\", value, usage)\n}\n\n// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.\nfunc IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {\n\treturn CommandLine.IPNetP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string.go",
"content": "package pflag\n\n// -- string Value\ntype stringValue string\n\nfunc newStringValue(val string, p *string) *stringValue {\n\t*p = val\n\treturn (*stringValue)(p)\n}\n\nfunc (s *stringValue) Set(val string) error {\n\t*s = stringValue(val)\n\treturn nil\n}\nfunc (s *stringValue) Type() string {\n\treturn \"string\"\n}\n\nfunc (s *stringValue) String() string { return string(*s) }\n\nfunc stringConv(sval string) (interface{}, error) {\n\treturn sval, nil\n}\n\n// GetString return the string value of a flag with the given name\nfunc (f *FlagSet) GetString(name string) (string, error) {\n\tval, err := f.getFlagType(name, \"string\", stringConv)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\treturn val.(string), nil\n}\n\n// StringVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a string variable in which to store the value of the flag.\nfunc (f *FlagSet) StringVar(p *string, name string, value string, usage string) {\n\tf.VarP(newStringValue(value, p), name, \"\", usage)\n}\n\n// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringVarP(p *string, name, shorthand string, value string, usage string) {\n\tf.VarP(newStringValue(value, p), name, shorthand, usage)\n}\n\n// StringVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a string variable in which to store the value of the flag.\nfunc StringVar(p *string, name string, value string, usage string) {\n\tCommandLine.VarP(newStringValue(value, p), name, \"\", usage)\n}\n\n// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.\nfunc StringVarP(p *string, name, shorthand string, value string, usage string) {\n\tCommandLine.VarP(newStringValue(value, p), name, shorthand, usage)\n}\n\n// String defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a string variable that stores the value of the flag.\nfunc (f *FlagSet) String(name string, value string, usage string) *string {\n\tp := new(string)\n\tf.StringVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// StringP is like String, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringP(name, shorthand string, value string, usage string) *string {\n\tp := new(string)\n\tf.StringVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// String defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a string variable that stores the value of the flag.\nfunc String(name string, value string, usage string) *string {\n\treturn CommandLine.StringP(name, \"\", value, usage)\n}\n\n// StringP is like String, but accepts a shorthand letter that can be used after a single dash.\nfunc StringP(name, shorthand string, value string, usage string) *string {\n\treturn CommandLine.StringP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string_array.go",
"content": "package pflag\n\n// -- stringArray Value\ntype stringArrayValue struct {\n\tvalue *[]string\n\tchanged bool\n}\n\nfunc newStringArrayValue(val []string, p *[]string) *stringArrayValue {\n\tssv := new(stringArrayValue)\n\tssv.value = p\n\t*ssv.value = val\n\treturn ssv\n}\n\nfunc (s *stringArrayValue) Set(val string) error {\n\tif !s.changed {\n\t\t*s.value = []string{val}\n\t\ts.changed = true\n\t} else {\n\t\t*s.value = append(*s.value, val)\n\t}\n\treturn nil\n}\n\nfunc (s *stringArrayValue) Append(val string) error {\n\t*s.value = append(*s.value, val)\n\treturn nil\n}\n\nfunc (s *stringArrayValue) Replace(val []string) error {\n\tout := make([]string, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i] = d\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *stringArrayValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = d\n\t}\n\treturn out\n}\n\nfunc (s *stringArrayValue) Type() string {\n\treturn \"stringArray\"\n}\n\nfunc (s *stringArrayValue) String() string {\n\tstr, _ := writeAsCSV(*s.value)\n\treturn \"[\" + str + \"]\"\n}\n\nfunc stringArrayConv(sval string) (interface{}, error) {\n\tsval = sval[1 : len(sval)-1]\n\t// An empty string would cause a array with one (empty) string\n\tif len(sval) == 0 {\n\t\treturn []string{}, nil\n\t}\n\treturn readAsCSV(sval)\n}\n\n// GetStringArray return the []string value of a flag with the given name\nfunc (f *FlagSet) GetStringArray(name string) ([]string, error) {\n\tval, err := f.getFlagType(name, \"stringArray\", stringArrayConv)\n\tif err != nil {\n\t\treturn []string{}, err\n\t}\n\treturn val.([]string), nil\n}\n\n// StringArrayVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a []string variable in which to store the values of the multiple flags.\n// The value of each argument will not try to be separated by comma. Use a StringSlice for that.\nfunc (f *FlagSet) StringArrayVar(p *[]string, name string, value []string, usage string) {\n\tf.VarP(newStringArrayValue(value, p), name, \"\", usage)\n}\n\n// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {\n\tf.VarP(newStringArrayValue(value, p), name, shorthand, usage)\n}\n\n// StringArrayVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a []string variable in which to store the value of the flag.\n// The value of each argument will not try to be separated by comma. Use a StringSlice for that.\nfunc StringArrayVar(p *[]string, name string, value []string, usage string) {\n\tCommandLine.VarP(newStringArrayValue(value, p), name, \"\", usage)\n}\n\n// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.\nfunc StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {\n\tCommandLine.VarP(newStringArrayValue(value, p), name, shorthand, usage)\n}\n\n// StringArray defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a []string variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma. Use a StringSlice for that.\nfunc (f *FlagSet) StringArray(name string, value []string, usage string) *[]string {\n\tp := []string{}\n\tf.StringArrayVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringArrayP(name, shorthand string, value []string, usage string) *[]string {\n\tp := []string{}\n\tf.StringArrayVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// StringArray defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a []string variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma. Use a StringSlice for that.\nfunc StringArray(name string, value []string, usage string) *[]string {\n\treturn CommandLine.StringArrayP(name, \"\", value, usage)\n}\n\n// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.\nfunc StringArrayP(name, shorthand string, value []string, usage string) *[]string {\n\treturn CommandLine.StringArrayP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string_slice.go",
"content": "package pflag\n\nimport (\n\t\"bytes\"\n\t\"encoding/csv\"\n\t\"strings\"\n)\n\n// -- stringSlice Value\ntype stringSliceValue struct {\n\tvalue *[]string\n\tchanged bool\n}\n\nfunc newStringSliceValue(val []string, p *[]string) *stringSliceValue {\n\tssv := new(stringSliceValue)\n\tssv.value = p\n\t*ssv.value = val\n\treturn ssv\n}\n\nfunc readAsCSV(val string) ([]string, error) {\n\tif val == \"\" {\n\t\treturn []string{}, nil\n\t}\n\tstringReader := strings.NewReader(val)\n\tcsvReader := csv.NewReader(stringReader)\n\treturn csvReader.Read()\n}\n\nfunc writeAsCSV(vals []string) (string, error) {\n\tb := &bytes.Buffer{}\n\tw := csv.NewWriter(b)\n\terr := w.Write(vals)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\tw.Flush()\n\treturn strings.TrimSuffix(b.String(), \"\\n\"), nil\n}\n\nfunc (s *stringSliceValue) Set(val string) error {\n\tv, err := readAsCSV(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\tif !s.changed {\n\t\t*s.value = v\n\t} else {\n\t\t*s.value = append(*s.value, v...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *stringSliceValue) Type() string {\n\treturn \"stringSlice\"\n}\n\nfunc (s *stringSliceValue) String() string {\n\tstr, _ := writeAsCSV(*s.value)\n\treturn \"[\" + str + \"]\"\n}\n\nfunc (s *stringSliceValue) Append(val string) error {\n\t*s.value = append(*s.value, val)\n\treturn nil\n}\n\nfunc (s *stringSliceValue) Replace(val []string) error {\n\t*s.value = val\n\treturn nil\n}\n\nfunc (s *stringSliceValue) GetSlice() []string {\n\treturn *s.value\n}\n\nfunc stringSliceConv(sval string) (interface{}, error) {\n\tsval = sval[1 : len(sval)-1]\n\t// An empty string would cause a slice with one (empty) string\n\tif len(sval) == 0 {\n\t\treturn []string{}, nil\n\t}\n\treturn readAsCSV(sval)\n}\n\n// GetStringSlice return the []string value of a flag with the given name\nfunc (f *FlagSet) GetStringSlice(name string) ([]string, error) {\n\tval, err := f.getFlagType(name, \"stringSlice\", stringSliceConv)\n\tif err != nil {\n\t\treturn []string{}, err\n\t}\n\treturn val.([]string), nil\n}\n\n// StringSliceVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a []string variable in which to store the value of the flag.\n// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.\n// For example:\n// --ss=\"v1,v2\" --ss=\"v3\"\n// will result in\n// []string{\"v1\", \"v2\", \"v3\"}\nfunc (f *FlagSet) StringSliceVar(p *[]string, name string, value []string, usage string) {\n\tf.VarP(newStringSliceValue(value, p), name, \"\", usage)\n}\n\n// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {\n\tf.VarP(newStringSliceValue(value, p), name, shorthand, usage)\n}\n\n// StringSliceVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a []string variable in which to store the value of the flag.\n// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.\n// For example:\n// --ss=\"v1,v2\" --ss=\"v3\"\n// will result in\n// []string{\"v1\", \"v2\", \"v3\"}\nfunc StringSliceVar(p *[]string, name string, value []string, usage string) {\n\tCommandLine.VarP(newStringSliceValue(value, p), name, \"\", usage)\n}\n\n// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {\n\tCommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage)\n}\n\n// StringSlice defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a []string variable that stores the value of the flag.\n// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.\n// For example:\n// --ss=\"v1,v2\" --ss=\"v3\"\n// will result in\n// []string{\"v1\", \"v2\", \"v3\"}\nfunc (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string {\n\tp := []string{}\n\tf.StringSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string {\n\tp := []string{}\n\tf.StringSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// StringSlice defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a []string variable that stores the value of the flag.\n// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.\n// For example:\n// --ss=\"v1,v2\" --ss=\"v3\"\n// will result in\n// []string{\"v1\", \"v2\", \"v3\"}\nfunc StringSlice(name string, value []string, usage string) *[]string {\n\treturn CommandLine.StringSliceP(name, \"\", value, usage)\n}\n\n// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc StringSliceP(name, shorthand string, value []string, usage string) *[]string {\n\treturn CommandLine.StringSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string_to_int.go",
"content": "package pflag\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- stringToInt Value\ntype stringToIntValue struct {\n\tvalue *map[string]int\n\tchanged bool\n}\n\nfunc newStringToIntValue(val map[string]int, p *map[string]int) *stringToIntValue {\n\tssv := new(stringToIntValue)\n\tssv.value = p\n\t*ssv.value = val\n\treturn ssv\n}\n\n// Format: a=1,b=2\nfunc (s *stringToIntValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make(map[string]int, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tvar err error\n\t\tout[kv[0]], err = strconv.Atoi(kv[1])\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\tfor k, v := range out {\n\t\t\t(*s.value)[k] = v\n\t\t}\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *stringToIntValue) Type() string {\n\treturn \"stringToInt\"\n}\n\nfunc (s *stringToIntValue) String() string {\n\tvar buf bytes.Buffer\n\ti := 0\n\tfor k, v := range *s.value {\n\t\tif i > 0 {\n\t\t\tbuf.WriteRune(',')\n\t\t}\n\t\tbuf.WriteString(k)\n\t\tbuf.WriteRune('=')\n\t\tbuf.WriteString(strconv.Itoa(v))\n\t\ti++\n\t}\n\treturn \"[\" + buf.String() + \"]\"\n}\n\nfunc stringToIntConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// An empty string would cause an empty map\n\tif len(val) == 0 {\n\t\treturn map[string]int{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make(map[string]int, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn nil, fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tvar err error\n\t\tout[kv[0]], err = strconv.Atoi(kv[1])\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\treturn out, nil\n}\n\n// GetStringToInt return the map[string]int value of a flag with the given name\nfunc (f *FlagSet) GetStringToInt(name string) (map[string]int, error) {\n\tval, err := f.getFlagType(name, \"stringToInt\", stringToIntConv)\n\tif err != nil {\n\t\treturn map[string]int{}, err\n\t}\n\treturn val.(map[string]int), nil\n}\n\n// StringToIntVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a map[string]int variable in which to store the values of the multiple flags.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToIntVar(p *map[string]int, name string, value map[string]int, usage string) {\n\tf.VarP(newStringToIntValue(value, p), name, \"\", usage)\n}\n\n// StringToIntVarP is like StringToIntVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToIntVarP(p *map[string]int, name, shorthand string, value map[string]int, usage string) {\n\tf.VarP(newStringToIntValue(value, p), name, shorthand, usage)\n}\n\n// StringToIntVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a map[string]int variable in which to store the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToIntVar(p *map[string]int, name string, value map[string]int, usage string) {\n\tCommandLine.VarP(newStringToIntValue(value, p), name, \"\", usage)\n}\n\n// StringToIntVarP is like StringToIntVar, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToIntVarP(p *map[string]int, name, shorthand string, value map[string]int, usage string) {\n\tCommandLine.VarP(newStringToIntValue(value, p), name, shorthand, usage)\n}\n\n// StringToInt defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]int variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToInt(name string, value map[string]int, usage string) *map[string]int {\n\tp := map[string]int{}\n\tf.StringToIntVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// StringToIntP is like StringToInt, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToIntP(name, shorthand string, value map[string]int, usage string) *map[string]int {\n\tp := map[string]int{}\n\tf.StringToIntVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// StringToInt defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]int variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToInt(name string, value map[string]int, usage string) *map[string]int {\n\treturn CommandLine.StringToIntP(name, \"\", value, usage)\n}\n\n// StringToIntP is like StringToInt, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToIntP(name, shorthand string, value map[string]int, usage string) *map[string]int {\n\treturn CommandLine.StringToIntP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string_to_int64.go",
"content": "package pflag\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- stringToInt64 Value\ntype stringToInt64Value struct {\n\tvalue *map[string]int64\n\tchanged bool\n}\n\nfunc newStringToInt64Value(val map[string]int64, p *map[string]int64) *stringToInt64Value {\n\tssv := new(stringToInt64Value)\n\tssv.value = p\n\t*ssv.value = val\n\treturn ssv\n}\n\n// Format: a=1,b=2\nfunc (s *stringToInt64Value) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make(map[string]int64, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tvar err error\n\t\tout[kv[0]], err = strconv.ParseInt(kv[1], 10, 64)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\tfor k, v := range out {\n\t\t\t(*s.value)[k] = v\n\t\t}\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *stringToInt64Value) Type() string {\n\treturn \"stringToInt64\"\n}\n\nfunc (s *stringToInt64Value) String() string {\n\tvar buf bytes.Buffer\n\ti := 0\n\tfor k, v := range *s.value {\n\t\tif i > 0 {\n\t\t\tbuf.WriteRune(',')\n\t\t}\n\t\tbuf.WriteString(k)\n\t\tbuf.WriteRune('=')\n\t\tbuf.WriteString(strconv.FormatInt(v, 10))\n\t\ti++\n\t}\n\treturn \"[\" + buf.String() + \"]\"\n}\n\nfunc stringToInt64Conv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// An empty string would cause an empty map\n\tif len(val) == 0 {\n\t\treturn map[string]int64{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make(map[string]int64, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn nil, fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tvar err error\n\t\tout[kv[0]], err = strconv.ParseInt(kv[1], 10, 64)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\treturn out, nil\n}\n\n// GetStringToInt64 return the map[string]int64 value of a flag with the given name\nfunc (f *FlagSet) GetStringToInt64(name string) (map[string]int64, error) {\n\tval, err := f.getFlagType(name, \"stringToInt64\", stringToInt64Conv)\n\tif err != nil {\n\t\treturn map[string]int64{}, err\n\t}\n\treturn val.(map[string]int64), nil\n}\n\n// StringToInt64Var defines a string flag with specified name, default value, and usage string.\n// The argument p point64s to a map[string]int64 variable in which to store the values of the multiple flags.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToInt64Var(p *map[string]int64, name string, value map[string]int64, usage string) {\n\tf.VarP(newStringToInt64Value(value, p), name, \"\", usage)\n}\n\n// StringToInt64VarP is like StringToInt64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToInt64VarP(p *map[string]int64, name, shorthand string, value map[string]int64, usage string) {\n\tf.VarP(newStringToInt64Value(value, p), name, shorthand, usage)\n}\n\n// StringToInt64Var defines a string flag with specified name, default value, and usage string.\n// The argument p point64s to a map[string]int64 variable in which to store the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToInt64Var(p *map[string]int64, name string, value map[string]int64, usage string) {\n\tCommandLine.VarP(newStringToInt64Value(value, p), name, \"\", usage)\n}\n\n// StringToInt64VarP is like StringToInt64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToInt64VarP(p *map[string]int64, name, shorthand string, value map[string]int64, usage string) {\n\tCommandLine.VarP(newStringToInt64Value(value, p), name, shorthand, usage)\n}\n\n// StringToInt64 defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]int64 variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToInt64(name string, value map[string]int64, usage string) *map[string]int64 {\n\tp := map[string]int64{}\n\tf.StringToInt64VarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// StringToInt64P is like StringToInt64, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToInt64P(name, shorthand string, value map[string]int64, usage string) *map[string]int64 {\n\tp := map[string]int64{}\n\tf.StringToInt64VarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// StringToInt64 defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]int64 variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToInt64(name string, value map[string]int64, usage string) *map[string]int64 {\n\treturn CommandLine.StringToInt64P(name, \"\", value, usage)\n}\n\n// StringToInt64P is like StringToInt64, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToInt64P(name, shorthand string, value map[string]int64, usage string) *map[string]int64 {\n\treturn CommandLine.StringToInt64P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/string_to_string.go",
"content": "package pflag\n\nimport (\n\t\"bytes\"\n\t\"encoding/csv\"\n\t\"fmt\"\n\t\"strings\"\n)\n\n// -- stringToString Value\ntype stringToStringValue struct {\n\tvalue *map[string]string\n\tchanged bool\n}\n\nfunc newStringToStringValue(val map[string]string, p *map[string]string) *stringToStringValue {\n\tssv := new(stringToStringValue)\n\tssv.value = p\n\t*ssv.value = val\n\treturn ssv\n}\n\n// Format: a=1,b=2\nfunc (s *stringToStringValue) Set(val string) error {\n\tvar ss []string\n\tn := strings.Count(val, \"=\")\n\tswitch n {\n\tcase 0:\n\t\treturn fmt.Errorf(\"%s must be formatted as key=value\", val)\n\tcase 1:\n\t\tss = append(ss, strings.Trim(val, `\"`))\n\tdefault:\n\t\tr := csv.NewReader(strings.NewReader(val))\n\t\tvar err error\n\t\tss, err = r.Read()\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\n\tout := make(map[string]string, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tout[kv[0]] = kv[1]\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\tfor k, v := range out {\n\t\t\t(*s.value)[k] = v\n\t\t}\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *stringToStringValue) Type() string {\n\treturn \"stringToString\"\n}\n\nfunc (s *stringToStringValue) String() string {\n\trecords := make([]string, 0, len(*s.value)>>1)\n\tfor k, v := range *s.value {\n\t\trecords = append(records, k+\"=\"+v)\n\t}\n\n\tvar buf bytes.Buffer\n\tw := csv.NewWriter(&buf)\n\tif err := w.Write(records); err != nil {\n\t\tpanic(err)\n\t}\n\tw.Flush()\n\treturn \"[\" + strings.TrimSpace(buf.String()) + \"]\"\n}\n\nfunc stringToStringConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// An empty string would cause an empty map\n\tif len(val) == 0 {\n\t\treturn map[string]string{}, nil\n\t}\n\tr := csv.NewReader(strings.NewReader(val))\n\tss, err := r.Read()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tout := make(map[string]string, len(ss))\n\tfor _, pair := range ss {\n\t\tkv := strings.SplitN(pair, \"=\", 2)\n\t\tif len(kv) != 2 {\n\t\t\treturn nil, fmt.Errorf(\"%s must be formatted as key=value\", pair)\n\t\t}\n\t\tout[kv[0]] = kv[1]\n\t}\n\treturn out, nil\n}\n\n// GetStringToString return the map[string]string value of a flag with the given name\nfunc (f *FlagSet) GetStringToString(name string) (map[string]string, error) {\n\tval, err := f.getFlagType(name, \"stringToString\", stringToStringConv)\n\tif err != nil {\n\t\treturn map[string]string{}, err\n\t}\n\treturn val.(map[string]string), nil\n}\n\n// StringToStringVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a map[string]string variable in which to store the values of the multiple flags.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToStringVar(p *map[string]string, name string, value map[string]string, usage string) {\n\tf.VarP(newStringToStringValue(value, p), name, \"\", usage)\n}\n\n// StringToStringVarP is like StringToStringVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToStringVarP(p *map[string]string, name, shorthand string, value map[string]string, usage string) {\n\tf.VarP(newStringToStringValue(value, p), name, shorthand, usage)\n}\n\n// StringToStringVar defines a string flag with specified name, default value, and usage string.\n// The argument p points to a map[string]string variable in which to store the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToStringVar(p *map[string]string, name string, value map[string]string, usage string) {\n\tCommandLine.VarP(newStringToStringValue(value, p), name, \"\", usage)\n}\n\n// StringToStringVarP is like StringToStringVar, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToStringVarP(p *map[string]string, name, shorthand string, value map[string]string, usage string) {\n\tCommandLine.VarP(newStringToStringValue(value, p), name, shorthand, usage)\n}\n\n// StringToString defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]string variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc (f *FlagSet) StringToString(name string, value map[string]string, usage string) *map[string]string {\n\tp := map[string]string{}\n\tf.StringToStringVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// StringToStringP is like StringToString, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) StringToStringP(name, shorthand string, value map[string]string, usage string) *map[string]string {\n\tp := map[string]string{}\n\tf.StringToStringVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// StringToString defines a string flag with specified name, default value, and usage string.\n// The return value is the address of a map[string]string variable that stores the value of the flag.\n// The value of each argument will not try to be separated by comma\nfunc StringToString(name string, value map[string]string, usage string) *map[string]string {\n\treturn CommandLine.StringToStringP(name, \"\", value, usage)\n}\n\n// StringToStringP is like StringToString, but accepts a shorthand letter that can be used after a single dash.\nfunc StringToStringP(name, shorthand string, value map[string]string, usage string) *map[string]string {\n\treturn CommandLine.StringToStringP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- uint Value\ntype uintValue uint\n\nfunc newUintValue(val uint, p *uint) *uintValue {\n\t*p = val\n\treturn (*uintValue)(p)\n}\n\nfunc (i *uintValue) Set(s string) error {\n\tv, err := strconv.ParseUint(s, 0, 64)\n\t*i = uintValue(v)\n\treturn err\n}\n\nfunc (i *uintValue) Type() string {\n\treturn \"uint\"\n}\n\nfunc (i *uintValue) String() string { return strconv.FormatUint(uint64(*i), 10) }\n\nfunc uintConv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseUint(sval, 0, 0)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint(v), nil\n}\n\n// GetUint return the uint value of a flag with the given name\nfunc (f *FlagSet) GetUint(name string) (uint, error) {\n\tval, err := f.getFlagType(name, \"uint\", uintConv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(uint), nil\n}\n\n// UintVar defines a uint flag with specified name, default value, and usage string.\n// The argument p points to a uint variable in which to store the value of the flag.\nfunc (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) {\n\tf.VarP(newUintValue(value, p), name, \"\", usage)\n}\n\n// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) UintVarP(p *uint, name, shorthand string, value uint, usage string) {\n\tf.VarP(newUintValue(value, p), name, shorthand, usage)\n}\n\n// UintVar defines a uint flag with specified name, default value, and usage string.\n// The argument p points to a uint variable in which to store the value of the flag.\nfunc UintVar(p *uint, name string, value uint, usage string) {\n\tCommandLine.VarP(newUintValue(value, p), name, \"\", usage)\n}\n\n// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.\nfunc UintVarP(p *uint, name, shorthand string, value uint, usage string) {\n\tCommandLine.VarP(newUintValue(value, p), name, shorthand, usage)\n}\n\n// Uint defines a uint flag with specified name, default value, and usage string.\n// The return value is the address of a uint variable that stores the value of the flag.\nfunc (f *FlagSet) Uint(name string, value uint, usage string) *uint {\n\tp := new(uint)\n\tf.UintVarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) UintP(name, shorthand string, value uint, usage string) *uint {\n\tp := new(uint)\n\tf.UintVarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Uint defines a uint flag with specified name, default value, and usage string.\n// The return value is the address of a uint variable that stores the value of the flag.\nfunc Uint(name string, value uint, usage string) *uint {\n\treturn CommandLine.UintP(name, \"\", value, usage)\n}\n\n// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.\nfunc UintP(name, shorthand string, value uint, usage string) *uint {\n\treturn CommandLine.UintP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint16.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- uint16 value\ntype uint16Value uint16\n\nfunc newUint16Value(val uint16, p *uint16) *uint16Value {\n\t*p = val\n\treturn (*uint16Value)(p)\n}\n\nfunc (i *uint16Value) Set(s string) error {\n\tv, err := strconv.ParseUint(s, 0, 16)\n\t*i = uint16Value(v)\n\treturn err\n}\n\nfunc (i *uint16Value) Type() string {\n\treturn \"uint16\"\n}\n\nfunc (i *uint16Value) String() string { return strconv.FormatUint(uint64(*i), 10) }\n\nfunc uint16Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseUint(sval, 0, 16)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint16(v), nil\n}\n\n// GetUint16 return the uint16 value of a flag with the given name\nfunc (f *FlagSet) GetUint16(name string) (uint16, error) {\n\tval, err := f.getFlagType(name, \"uint16\", uint16Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(uint16), nil\n}\n\n// Uint16Var defines a uint flag with specified name, default value, and usage string.\n// The argument p points to a uint variable in which to store the value of the flag.\nfunc (f *FlagSet) Uint16Var(p *uint16, name string, value uint16, usage string) {\n\tf.VarP(newUint16Value(value, p), name, \"\", usage)\n}\n\n// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {\n\tf.VarP(newUint16Value(value, p), name, shorthand, usage)\n}\n\n// Uint16Var defines a uint flag with specified name, default value, and usage string.\n// The argument p points to a uint variable in which to store the value of the flag.\nfunc Uint16Var(p *uint16, name string, value uint16, usage string) {\n\tCommandLine.VarP(newUint16Value(value, p), name, \"\", usage)\n}\n\n// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {\n\tCommandLine.VarP(newUint16Value(value, p), name, shorthand, usage)\n}\n\n// Uint16 defines a uint flag with specified name, default value, and usage string.\n// The return value is the address of a uint variable that stores the value of the flag.\nfunc (f *FlagSet) Uint16(name string, value uint16, usage string) *uint16 {\n\tp := new(uint16)\n\tf.Uint16VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint16P(name, shorthand string, value uint16, usage string) *uint16 {\n\tp := new(uint16)\n\tf.Uint16VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Uint16 defines a uint flag with specified name, default value, and usage string.\n// The return value is the address of a uint variable that stores the value of the flag.\nfunc Uint16(name string, value uint16, usage string) *uint16 {\n\treturn CommandLine.Uint16P(name, \"\", value, usage)\n}\n\n// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint16P(name, shorthand string, value uint16, usage string) *uint16 {\n\treturn CommandLine.Uint16P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint32.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- uint32 value\ntype uint32Value uint32\n\nfunc newUint32Value(val uint32, p *uint32) *uint32Value {\n\t*p = val\n\treturn (*uint32Value)(p)\n}\n\nfunc (i *uint32Value) Set(s string) error {\n\tv, err := strconv.ParseUint(s, 0, 32)\n\t*i = uint32Value(v)\n\treturn err\n}\n\nfunc (i *uint32Value) Type() string {\n\treturn \"uint32\"\n}\n\nfunc (i *uint32Value) String() string { return strconv.FormatUint(uint64(*i), 10) }\n\nfunc uint32Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseUint(sval, 0, 32)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint32(v), nil\n}\n\n// GetUint32 return the uint32 value of a flag with the given name\nfunc (f *FlagSet) GetUint32(name string) (uint32, error) {\n\tval, err := f.getFlagType(name, \"uint32\", uint32Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(uint32), nil\n}\n\n// Uint32Var defines a uint32 flag with specified name, default value, and usage string.\n// The argument p points to a uint32 variable in which to store the value of the flag.\nfunc (f *FlagSet) Uint32Var(p *uint32, name string, value uint32, usage string) {\n\tf.VarP(newUint32Value(value, p), name, \"\", usage)\n}\n\n// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) {\n\tf.VarP(newUint32Value(value, p), name, shorthand, usage)\n}\n\n// Uint32Var defines a uint32 flag with specified name, default value, and usage string.\n// The argument p points to a uint32 variable in which to store the value of the flag.\nfunc Uint32Var(p *uint32, name string, value uint32, usage string) {\n\tCommandLine.VarP(newUint32Value(value, p), name, \"\", usage)\n}\n\n// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) {\n\tCommandLine.VarP(newUint32Value(value, p), name, shorthand, usage)\n}\n\n// Uint32 defines a uint32 flag with specified name, default value, and usage string.\n// The return value is the address of a uint32 variable that stores the value of the flag.\nfunc (f *FlagSet) Uint32(name string, value uint32, usage string) *uint32 {\n\tp := new(uint32)\n\tf.Uint32VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint32P(name, shorthand string, value uint32, usage string) *uint32 {\n\tp := new(uint32)\n\tf.Uint32VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Uint32 defines a uint32 flag with specified name, default value, and usage string.\n// The return value is the address of a uint32 variable that stores the value of the flag.\nfunc Uint32(name string, value uint32, usage string) *uint32 {\n\treturn CommandLine.Uint32P(name, \"\", value, usage)\n}\n\n// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint32P(name, shorthand string, value uint32, usage string) *uint32 {\n\treturn CommandLine.Uint32P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint64.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- uint64 Value\ntype uint64Value uint64\n\nfunc newUint64Value(val uint64, p *uint64) *uint64Value {\n\t*p = val\n\treturn (*uint64Value)(p)\n}\n\nfunc (i *uint64Value) Set(s string) error {\n\tv, err := strconv.ParseUint(s, 0, 64)\n\t*i = uint64Value(v)\n\treturn err\n}\n\nfunc (i *uint64Value) Type() string {\n\treturn \"uint64\"\n}\n\nfunc (i *uint64Value) String() string { return strconv.FormatUint(uint64(*i), 10) }\n\nfunc uint64Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseUint(sval, 0, 64)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint64(v), nil\n}\n\n// GetUint64 return the uint64 value of a flag with the given name\nfunc (f *FlagSet) GetUint64(name string) (uint64, error) {\n\tval, err := f.getFlagType(name, \"uint64\", uint64Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(uint64), nil\n}\n\n// Uint64Var defines a uint64 flag with specified name, default value, and usage string.\n// The argument p points to a uint64 variable in which to store the value of the flag.\nfunc (f *FlagSet) Uint64Var(p *uint64, name string, value uint64, usage string) {\n\tf.VarP(newUint64Value(value, p), name, \"\", usage)\n}\n\n// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) {\n\tf.VarP(newUint64Value(value, p), name, shorthand, usage)\n}\n\n// Uint64Var defines a uint64 flag with specified name, default value, and usage string.\n// The argument p points to a uint64 variable in which to store the value of the flag.\nfunc Uint64Var(p *uint64, name string, value uint64, usage string) {\n\tCommandLine.VarP(newUint64Value(value, p), name, \"\", usage)\n}\n\n// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) {\n\tCommandLine.VarP(newUint64Value(value, p), name, shorthand, usage)\n}\n\n// Uint64 defines a uint64 flag with specified name, default value, and usage string.\n// The return value is the address of a uint64 variable that stores the value of the flag.\nfunc (f *FlagSet) Uint64(name string, value uint64, usage string) *uint64 {\n\tp := new(uint64)\n\tf.Uint64VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint64P(name, shorthand string, value uint64, usage string) *uint64 {\n\tp := new(uint64)\n\tf.Uint64VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Uint64 defines a uint64 flag with specified name, default value, and usage string.\n// The return value is the address of a uint64 variable that stores the value of the flag.\nfunc Uint64(name string, value uint64, usage string) *uint64 {\n\treturn CommandLine.Uint64P(name, \"\", value, usage)\n}\n\n// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint64P(name, shorthand string, value uint64, usage string) *uint64 {\n\treturn CommandLine.Uint64P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint8.go",
"content": "package pflag\n\nimport \"strconv\"\n\n// -- uint8 Value\ntype uint8Value uint8\n\nfunc newUint8Value(val uint8, p *uint8) *uint8Value {\n\t*p = val\n\treturn (*uint8Value)(p)\n}\n\nfunc (i *uint8Value) Set(s string) error {\n\tv, err := strconv.ParseUint(s, 0, 8)\n\t*i = uint8Value(v)\n\treturn err\n}\n\nfunc (i *uint8Value) Type() string {\n\treturn \"uint8\"\n}\n\nfunc (i *uint8Value) String() string { return strconv.FormatUint(uint64(*i), 10) }\n\nfunc uint8Conv(sval string) (interface{}, error) {\n\tv, err := strconv.ParseUint(sval, 0, 8)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint8(v), nil\n}\n\n// GetUint8 return the uint8 value of a flag with the given name\nfunc (f *FlagSet) GetUint8(name string) (uint8, error) {\n\tval, err := f.getFlagType(name, \"uint8\", uint8Conv)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn val.(uint8), nil\n}\n\n// Uint8Var defines a uint8 flag with specified name, default value, and usage string.\n// The argument p points to a uint8 variable in which to store the value of the flag.\nfunc (f *FlagSet) Uint8Var(p *uint8, name string, value uint8, usage string) {\n\tf.VarP(newUint8Value(value, p), name, \"\", usage)\n}\n\n// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) {\n\tf.VarP(newUint8Value(value, p), name, shorthand, usage)\n}\n\n// Uint8Var defines a uint8 flag with specified name, default value, and usage string.\n// The argument p points to a uint8 variable in which to store the value of the flag.\nfunc Uint8Var(p *uint8, name string, value uint8, usage string) {\n\tCommandLine.VarP(newUint8Value(value, p), name, \"\", usage)\n}\n\n// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) {\n\tCommandLine.VarP(newUint8Value(value, p), name, shorthand, usage)\n}\n\n// Uint8 defines a uint8 flag with specified name, default value, and usage string.\n// The return value is the address of a uint8 variable that stores the value of the flag.\nfunc (f *FlagSet) Uint8(name string, value uint8, usage string) *uint8 {\n\tp := new(uint8)\n\tf.Uint8VarP(p, name, \"\", value, usage)\n\treturn p\n}\n\n// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) Uint8P(name, shorthand string, value uint8, usage string) *uint8 {\n\tp := new(uint8)\n\tf.Uint8VarP(p, name, shorthand, value, usage)\n\treturn p\n}\n\n// Uint8 defines a uint8 flag with specified name, default value, and usage string.\n// The return value is the address of a uint8 variable that stores the value of the flag.\nfunc Uint8(name string, value uint8, usage string) *uint8 {\n\treturn CommandLine.Uint8P(name, \"\", value, usage)\n}\n\n// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash.\nfunc Uint8P(name, shorthand string, value uint8, usage string) *uint8 {\n\treturn CommandLine.Uint8P(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/github.com/spf13/pflag/uint_slice.go",
"content": "package pflag\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// -- uintSlice Value\ntype uintSliceValue struct {\n\tvalue *[]uint\n\tchanged bool\n}\n\nfunc newUintSliceValue(val []uint, p *[]uint) *uintSliceValue {\n\tuisv := new(uintSliceValue)\n\tuisv.value = p\n\t*uisv.value = val\n\treturn uisv\n}\n\nfunc (s *uintSliceValue) Set(val string) error {\n\tss := strings.Split(val, \",\")\n\tout := make([]uint, len(ss))\n\tfor i, d := range ss {\n\t\tu, err := strconv.ParseUint(d, 10, 0)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tout[i] = uint(u)\n\t}\n\tif !s.changed {\n\t\t*s.value = out\n\t} else {\n\t\t*s.value = append(*s.value, out...)\n\t}\n\ts.changed = true\n\treturn nil\n}\n\nfunc (s *uintSliceValue) Type() string {\n\treturn \"uintSlice\"\n}\n\nfunc (s *uintSliceValue) String() string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = fmt.Sprintf(\"%d\", d)\n\t}\n\treturn \"[\" + strings.Join(out, \",\") + \"]\"\n}\n\nfunc (s *uintSliceValue) fromString(val string) (uint, error) {\n\tt, err := strconv.ParseUint(val, 10, 0)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\treturn uint(t), nil\n}\n\nfunc (s *uintSliceValue) toString(val uint) string {\n\treturn fmt.Sprintf(\"%d\", val)\n}\n\nfunc (s *uintSliceValue) Append(val string) error {\n\ti, err := s.fromString(val)\n\tif err != nil {\n\t\treturn err\n\t}\n\t*s.value = append(*s.value, i)\n\treturn nil\n}\n\nfunc (s *uintSliceValue) Replace(val []string) error {\n\tout := make([]uint, len(val))\n\tfor i, d := range val {\n\t\tvar err error\n\t\tout[i], err = s.fromString(d)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\t*s.value = out\n\treturn nil\n}\n\nfunc (s *uintSliceValue) GetSlice() []string {\n\tout := make([]string, len(*s.value))\n\tfor i, d := range *s.value {\n\t\tout[i] = s.toString(d)\n\t}\n\treturn out\n}\n\nfunc uintSliceConv(val string) (interface{}, error) {\n\tval = strings.Trim(val, \"[]\")\n\t// Empty string would cause a slice with one (empty) entry\n\tif len(val) == 0 {\n\t\treturn []uint{}, nil\n\t}\n\tss := strings.Split(val, \",\")\n\tout := make([]uint, len(ss))\n\tfor i, d := range ss {\n\t\tu, err := strconv.ParseUint(d, 10, 0)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tout[i] = uint(u)\n\t}\n\treturn out, nil\n}\n\n// GetUintSlice returns the []uint value of a flag with the given name.\nfunc (f *FlagSet) GetUintSlice(name string) ([]uint, error) {\n\tval, err := f.getFlagType(name, \"uintSlice\", uintSliceConv)\n\tif err != nil {\n\t\treturn []uint{}, err\n\t}\n\treturn val.([]uint), nil\n}\n\n// UintSliceVar defines a uintSlice flag with specified name, default value, and usage string.\n// The argument p points to a []uint variable in which to store the value of the flag.\nfunc (f *FlagSet) UintSliceVar(p *[]uint, name string, value []uint, usage string) {\n\tf.VarP(newUintSliceValue(value, p), name, \"\", usage)\n}\n\n// UintSliceVarP is like UintSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) UintSliceVarP(p *[]uint, name, shorthand string, value []uint, usage string) {\n\tf.VarP(newUintSliceValue(value, p), name, shorthand, usage)\n}\n\n// UintSliceVar defines a uint[] flag with specified name, default value, and usage string.\n// The argument p points to a uint[] variable in which to store the value of the flag.\nfunc UintSliceVar(p *[]uint, name string, value []uint, usage string) {\n\tCommandLine.VarP(newUintSliceValue(value, p), name, \"\", usage)\n}\n\n// UintSliceVarP is like the UintSliceVar, but accepts a shorthand letter that can be used after a single dash.\nfunc UintSliceVarP(p *[]uint, name, shorthand string, value []uint, usage string) {\n\tCommandLine.VarP(newUintSliceValue(value, p), name, shorthand, usage)\n}\n\n// UintSlice defines a []uint flag with specified name, default value, and usage string.\n// The return value is the address of a []uint variable that stores the value of the flag.\nfunc (f *FlagSet) UintSlice(name string, value []uint, usage string) *[]uint {\n\tp := []uint{}\n\tf.UintSliceVarP(&p, name, \"\", value, usage)\n\treturn &p\n}\n\n// UintSliceP is like UintSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc (f *FlagSet) UintSliceP(name, shorthand string, value []uint, usage string) *[]uint {\n\tp := []uint{}\n\tf.UintSliceVarP(&p, name, shorthand, value, usage)\n\treturn &p\n}\n\n// UintSlice defines a []uint flag with specified name, default value, and usage string.\n// The return value is the address of a []uint variable that stores the value of the flag.\nfunc UintSlice(name string, value []uint, usage string) *[]uint {\n\treturn CommandLine.UintSliceP(name, \"\", value, usage)\n}\n\n// UintSliceP is like UintSlice, but accepts a shorthand letter that can be used after a single dash.\nfunc UintSliceP(name, shorthand string, value []uint, usage string) *[]uint {\n\treturn CommandLine.UintSliceP(name, shorthand, value, usage)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/AUTHORS",
"content": "# This source code refers to The Go Authors for copyright purposes.\n# The master list of authors is in the main Go distribution,\n# visible at http://tip.golang.org/AUTHORS.\n"
},
{
"path": "vendor/golang.org/x/sys/CONTRIBUTORS",
"content": "# This source code was written by the Go contributors.\n# The master list of contributors is in the main Go distribution,\n# visible at http://tip.golang.org/CONTRIBUTORS.\n"
},
{
"path": "vendor/golang.org/x/sys/LICENSE",
"content": "Copyright (c) 2009 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/golang.org/x/sys/PATENTS",
"content": "Additional IP Rights Grant (Patents)\n\n\"This implementation\" means the copyrightable works distributed by\nGoogle as part of the Go project.\n\nGoogle hereby grants to You a perpetual, worldwide, non-exclusive,\nno-charge, royalty-free, irrevocable (except as stated in this section)\npatent license to make, have made, use, offer to sell, sell, import,\ntransfer and otherwise run, modify and propagate the contents of this\nimplementation of Go, where such license applies only to those patent\nclaims, both currently owned or controlled by Google and acquired in\nthe future, licensable by Google that are necessarily infringed by this\nimplementation of Go. This grant does not include claims that would be\ninfringed only as a consequence of further modification of this\nimplementation. If you or your agent or exclusive licensee institute or\norder or agree to the institution of patent litigation against any\nentity (including a cross-claim or counterclaim in a lawsuit) alleging\nthat this implementation of Go or any code incorporated within this\nimplementation of Go constitutes direct or contributory patent\ninfringement, or inducement of patent infringement, then any patent\nrights granted to you under this License for this implementation of Go\nshall terminate as of the date such litigation is filed.\n"
},
{
"path": "vendor/golang.org/x/sys/internal/unsafeheader/unsafeheader.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package unsafeheader contains header declarations for the Go runtime's\n// slice and string implementations.\n//\n// This package allows x/sys to use types equivalent to\n// reflect.SliceHeader and reflect.StringHeader without introducing\n// a dependency on the (relatively heavy) \"reflect\" package.\npackage unsafeheader\n\nimport (\n\t\"unsafe\"\n)\n\n// Slice is the runtime representation of a slice.\n// It cannot be used safely or portably and its representation may change in a later release.\ntype Slice struct {\n\tData unsafe.Pointer\n\tLen int\n\tCap int\n}\n\n// String is the runtime representation of a string.\n// It cannot be used safely or portably and its representation may change in a later release.\ntype String struct {\n\tData unsafe.Pointer\n\tLen int\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/.gitignore",
"content": "_obj/\nunix.test\n"
},
{
"path": "vendor/golang.org/x/sys/unix/README.md",
"content": "# Building `sys/unix`\n\nThe sys/unix package provides access to the raw system call interface of the\nunderlying operating system. See: https://godoc.org/golang.org/x/sys/unix\n\nPorting Go to a new architecture/OS combination or adding syscalls, types, or\nconstants to an existing architecture/OS pair requires some manual effort;\nhowever, there are tools that automate much of the process.\n\n## Build Systems\n\nThere are currently two ways we generate the necessary files. We are currently\nmigrating the build system to use containers so the builds are reproducible.\nThis is being done on an OS-by-OS basis. Please update this documentation as\ncomponents of the build system change.\n\n### Old Build System (currently for `GOOS != \"linux\"`)\n\nThe old build system generates the Go files based on the C header files\npresent on your system. This means that files\nfor a given GOOS/GOARCH pair must be generated on a system with that OS and\narchitecture. This also means that the generated code can differ from system\nto system, based on differences in the header files.\n\nTo avoid this, if you are using the old build system, only generate the Go\nfiles on an installation with unmodified header files. It is also important to\nkeep track of which version of the OS the files were generated from (ex.\nDarwin 14 vs Darwin 15). This makes it easier to track the progress of changes\nand have each OS upgrade correspond to a single change.\n\nTo build the files for your current OS and architecture, make sure GOOS and\nGOARCH are set correctly and run `mkall.sh`. This will generate the files for\nyour specific system. Running `mkall.sh -n` shows the commands that will be run.\n\nRequirements: bash, go\n\n### New Build System (currently for `GOOS == \"linux\"`)\n\nThe new build system uses a Docker container to generate the go files directly\nfrom source checkouts of the kernel and various system libraries. This means\nthat on any platform that supports Docker, all the files using the new build\nsystem can be generated at once, and generated files will not change based on\nwhat the person running the scripts has installed on their computer.\n\nThe OS specific files for the new build system are located in the `${GOOS}`\ndirectory, and the build is coordinated by the `${GOOS}/mkall.go` program. When\nthe kernel or system library updates, modify the Dockerfile at\n`${GOOS}/Dockerfile` to checkout the new release of the source.\n\nTo build all the files under the new build system, you must be on an amd64/Linux\nsystem and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will\nthen generate all of the files for all of the GOOS/GOARCH pairs in the new build\nsystem. Running `mkall.sh -n` shows the commands that will be run.\n\nRequirements: bash, go, docker\n\n## Component files\n\nThis section describes the various files used in the code generation process.\nIt also contains instructions on how to modify these files to add a new\narchitecture/OS or to add additional syscalls, types, or constants. Note that\nif you are using the new build system, the scripts/programs cannot be called normally.\nThey must be called from within the docker container.\n\n### asm files\n\nThe hand-written assembly file at `asm_${GOOS}_${GOARCH}.s` implements system\ncall dispatch. There are three entry points:\n```\n func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)\n func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)\n func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)\n```\nThe first and second are the standard ones; they differ only in how many\narguments can be passed to the kernel. The third is for low-level use by the\nForkExec wrapper. Unlike the first two, it does not call into the scheduler to\nlet it know that a system call is running.\n\nWhen porting Go to a new architecture/OS, this file must be implemented for\neach GOOS/GOARCH pair.\n\n### mksysnum\n\nMksysnum is a Go program located at `${GOOS}/mksysnum.go` (or `mksysnum_${GOOS}.go`\nfor the old system). This program takes in a list of header files containing the\nsyscall number declarations and parses them to produce the corresponding list of\nGo numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated\nconstants.\n\nAdding new syscall numbers is mostly done by running the build on a sufficiently\nnew installation of the target OS (or updating the source checkouts for the\nnew build system). However, depending on the OS, you may need to update the\nparsing in mksysnum.\n\n### mksyscall.go\n\nThe `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are\nhand-written Go files which implement system calls (for unix, the specific OS,\nor the specific OS/Architecture pair respectively) that need special handling\nand list `//sys` comments giving prototypes for ones that can be generated.\n\nThe mksyscall.go program takes the `//sys` and `//sysnb` comments and converts\nthem into syscalls. This requires the name of the prototype in the comment to\nmatch a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function\nprototype can be exported (capitalized) or not.\n\nAdding a new syscall often just requires adding a new `//sys` function prototype\nwith the desired arguments and a capitalized name so it is exported. However, if\nyou want the interface to the syscall to be different, often one will make an\nunexported `//sys` prototype, and then write a custom wrapper in\n`syscall_${GOOS}.go`.\n\n### types files\n\nFor each OS, there is a hand-written Go file at `${GOOS}/types.go` (or\n`types_${GOOS}.go` on the old system). This file includes standard C headers and\ncreates Go type aliases to the corresponding C types. The file is then fed\nthrough godef to get the Go compatible definitions. Finally, the generated code\nis fed though mkpost.go to format the code correctly and remove any hidden or\nprivate identifiers. This cleaned-up code is written to\n`ztypes_${GOOS}_${GOARCH}.go`.\n\nThe hardest part about preparing this file is figuring out which headers to\ninclude and which symbols need to be `#define`d to get the actual data\nstructures that pass through to the kernel system calls. Some C libraries\npreset alternate versions for binary compatibility and translate them on the\nway in and out of system calls, but there is almost always a `#define` that can\nget the real ones.\nSee `types_darwin.go` and `linux/types.go` for examples.\n\nTo add a new type, add in the necessary include statement at the top of the\nfile (if it is not already there) and add in a type alias line. Note that if\nyour type is significantly different on different architectures, you may need\nsome `#if/#elif` macros in your include statements.\n\n### mkerrors.sh\n\nThis script is used to generate the system's various constants. This doesn't\njust include the error numbers and error strings, but also the signal numbers\nand a wide variety of miscellaneous constants. The constants come from the list\nof include files in the `includes_${uname}` variable. A regex then picks out\nthe desired `#define` statements, and generates the corresponding Go constants.\nThe error numbers and strings are generated from `#include `, and the\nsignal numbers and strings are generated from `#include `. All of\nthese constants are written to `zerrors_${GOOS}_${GOARCH}.go` via a C program,\n`_errors.c`, which prints out all the constants.\n\nTo add a constant, add the header that includes it to the appropriate variable.\nThen, edit the regex (if necessary) to match the desired constant. Avoid making\nthe regex too broad to avoid matching unintended constants.\n\n### internal/mkmerge\n\nThis program is used to extract duplicate const, func, and type declarations\nfrom the generated architecture-specific files listed below, and merge these\ninto a common file for each OS.\n\nThe merge is performed in the following steps:\n1. Construct the set of common code that is idential in all architecture-specific files.\n2. Write this common code to the merged file.\n3. Remove the common code from all architecture-specific files.\n\n\n## Generated files\n\n### `zerrors_${GOOS}_${GOARCH}.go`\n\nA file containing all of the system's generated error numbers, error strings,\nsignal numbers, and constants. Generated by `mkerrors.sh` (see above).\n\n### `zsyscall_${GOOS}_${GOARCH}.go`\n\nA file containing all the generated syscalls for a specific GOOS and GOARCH.\nGenerated by `mksyscall.go` (see above).\n\n### `zsysnum_${GOOS}_${GOARCH}.go`\n\nA list of numeric constants for all the syscall number of the specific GOOS\nand GOARCH. Generated by mksysnum (see above).\n\n### `ztypes_${GOOS}_${GOARCH}.go`\n\nA file containing Go types for passing into (or returning from) syscalls.\nGenerated by godefs and the types file (see above).\n"
},
{
"path": "vendor/golang.org/x/sys/unix/affinity_linux.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// CPU affinity functions\n\npackage unix\n\nimport (\n\t\"math/bits\"\n\t\"unsafe\"\n)\n\nconst cpuSetSize = _CPU_SETSIZE / _NCPUBITS\n\n// CPUSet represents a CPU affinity mask.\ntype CPUSet [cpuSetSize]cpuMask\n\nfunc schedAffinity(trap uintptr, pid int, set *CPUSet) error {\n\t_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))\n\tif e != 0 {\n\t\treturn errnoErr(e)\n\t}\n\treturn nil\n}\n\n// SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.\n// If pid is 0 the calling thread is used.\nfunc SchedGetaffinity(pid int, set *CPUSet) error {\n\treturn schedAffinity(SYS_SCHED_GETAFFINITY, pid, set)\n}\n\n// SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.\n// If pid is 0 the calling thread is used.\nfunc SchedSetaffinity(pid int, set *CPUSet) error {\n\treturn schedAffinity(SYS_SCHED_SETAFFINITY, pid, set)\n}\n\n// Zero clears the set s, so that it contains no CPUs.\nfunc (s *CPUSet) Zero() {\n\tfor i := range s {\n\t\ts[i] = 0\n\t}\n}\n\nfunc cpuBitsIndex(cpu int) int {\n\treturn cpu / _NCPUBITS\n}\n\nfunc cpuBitsMask(cpu int) cpuMask {\n\treturn cpuMask(1 << (uint(cpu) % _NCPUBITS))\n}\n\n// Set adds cpu to the set s.\nfunc (s *CPUSet) Set(cpu int) {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\ts[i] |= cpuBitsMask(cpu)\n\t}\n}\n\n// Clear removes cpu from the set s.\nfunc (s *CPUSet) Clear(cpu int) {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\ts[i] &^= cpuBitsMask(cpu)\n\t}\n}\n\n// IsSet reports whether cpu is in the set s.\nfunc (s *CPUSet) IsSet(cpu int) bool {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\treturn s[i]&cpuBitsMask(cpu) != 0\n\t}\n\treturn false\n}\n\n// Count returns the number of CPUs in the set s.\nfunc (s *CPUSet) Count() int {\n\tc := 0\n\tfor _, b := range s {\n\t\tc += bits.OnesCount64(uint64(b))\n\t}\n\treturn c\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/aliases.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos\n// +build go1.9\n\npackage unix\n\nimport \"syscall\"\n\ntype Signal = syscall.Signal\ntype Errno = syscall.Errno\ntype SysProcAttr = syscall.SysProcAttr\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_aix_ppc64.s",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for ppc64, AIX are implemented in runtime/syscall_aix.go\n//\n\nTEXT ·syscall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·syscall6(SB)\n\nTEXT ·rawSyscall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·rawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_386.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (freebsd || netbsd || openbsd) && gc\n// +build freebsd netbsd openbsd\n// +build gc\n\n#include \"textflag.h\"\n\n// System call support for 386 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-52\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_amd64.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc\n// +build darwin dragonfly freebsd netbsd openbsd\n// +build gc\n\n#include \"textflag.h\"\n\n// System call support for AMD64 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_arm.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (freebsd || netbsd || openbsd) && gc\n// +build freebsd netbsd openbsd\n// +build gc\n\n#include \"textflag.h\"\n\n// System call support for ARM BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-52\n\tB\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_arm64.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || freebsd || netbsd || openbsd) && gc\n// +build darwin freebsd netbsd openbsd\n// +build gc\n\n#include \"textflag.h\"\n\n// System call support for ARM64 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_386.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for 386, Linux\n//\n\n// See ../runtime/sys_linux_386.s for the reason why we always use int 0x80\n// instead of the glibc-specific \"CALL 0x10(GS)\".\n#define INVOKE_SYSCALL\tINT\t$0x80\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tCALL\truntime·entersyscall(SB)\n\tMOVL\ttrap+0(FP), AX // syscall entry\n\tMOVL\ta1+4(FP), BX\n\tMOVL\ta2+8(FP), CX\n\tMOVL\ta3+12(FP), DX\n\tMOVL\t$0, SI\n\tMOVL\t$0, DI\n\tINVOKE_SYSCALL\n\tMOVL\tAX, r1+16(FP)\n\tMOVL\tDX, r2+20(FP)\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVL\ttrap+0(FP), AX // syscall entry\n\tMOVL\ta1+4(FP), BX\n\tMOVL\ta2+8(FP), CX\n\tMOVL\ta3+12(FP), DX\n\tMOVL\t$0, SI\n\tMOVL\t$0, DI\n\tINVOKE_SYSCALL\n\tMOVL\tAX, r1+16(FP)\n\tMOVL\tDX, r2+20(FP)\n\tRET\n\nTEXT ·socketcall(SB),NOSPLIT,$0-36\n\tJMP\tsyscall·socketcall(SB)\n\nTEXT ·rawsocketcall(SB),NOSPLIT,$0-36\n\tJMP\tsyscall·rawsocketcall(SB)\n\nTEXT ·seek(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·seek(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_amd64.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for AMD64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tCALL\truntime·entersyscall(SB)\n\tMOVQ\ta1+8(FP), DI\n\tMOVQ\ta2+16(FP), SI\n\tMOVQ\ta3+24(FP), DX\n\tMOVQ\t$0, R10\n\tMOVQ\t$0, R8\n\tMOVQ\t$0, R9\n\tMOVQ\ttrap+0(FP), AX\t// syscall entry\n\tSYSCALL\n\tMOVQ\tAX, r1+32(FP)\n\tMOVQ\tDX, r2+40(FP)\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVQ\ta1+8(FP), DI\n\tMOVQ\ta2+16(FP), SI\n\tMOVQ\ta3+24(FP), DX\n\tMOVQ\t$0, R10\n\tMOVQ\t$0, R8\n\tMOVQ\t$0, R9\n\tMOVQ\ttrap+0(FP), AX\t// syscall entry\n\tSYSCALL\n\tMOVQ\tAX, r1+32(FP)\n\tMOVQ\tDX, r2+40(FP)\n\tRET\n\nTEXT ·gettimeofday(SB),NOSPLIT,$0-16\n\tJMP\tsyscall·gettimeofday(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_arm.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for arm, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tBL\truntime·entersyscall(SB)\n\tMOVW\ttrap+0(FP), R7\n\tMOVW\ta1+4(FP), R0\n\tMOVW\ta2+8(FP), R1\n\tMOVW\ta3+12(FP), R2\n\tMOVW\t$0, R3\n\tMOVW\t$0, R4\n\tMOVW\t$0, R5\n\tSWI\t$0\n\tMOVW\tR0, r1+16(FP)\n\tMOVW\t$0, R0\n\tMOVW\tR0, r2+20(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVW\ttrap+0(FP), R7\t// syscall entry\n\tMOVW\ta1+4(FP), R0\n\tMOVW\ta2+8(FP), R1\n\tMOVW\ta3+12(FP), R2\n\tSWI\t$0\n\tMOVW\tR0, r1+16(FP)\n\tMOVW\t$0, R0\n\tMOVW\tR0, r2+20(FP)\n\tRET\n\nTEXT ·seek(SB),NOSPLIT,$0-28\n\tB\tsyscall·seek(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_arm64.s",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && arm64 && gc\n// +build linux\n// +build arm64\n// +build gc\n\n#include \"textflag.h\"\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tB\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tB\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R0\n\tMOVD\ta2+16(FP), R1\n\tMOVD\ta3+24(FP), R2\n\tMOVD\t$0, R3\n\tMOVD\t$0, R4\n\tMOVD\t$0, R5\n\tMOVD\ttrap+0(FP), R8\t// syscall entry\n\tSVC\n\tMOVD\tR0, r1+32(FP)\t// r1\n\tMOVD\tR1, r2+40(FP)\t// r2\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tB\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R0\n\tMOVD\ta2+16(FP), R1\n\tMOVD\ta3+24(FP), R2\n\tMOVD\t$0, R3\n\tMOVD\t$0, R4\n\tMOVD\t$0, R5\n\tMOVD\ttrap+0(FP), R8\t// syscall entry\n\tSVC\n\tMOVD\tR0, r1+32(FP)\n\tMOVD\tR1, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_loong64.s",
"content": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && loong64 && gc\n// +build linux\n// +build loong64\n// +build gc\n\n#include \"textflag.h\"\n\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tJAL\truntime·entersyscall(SB)\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R11\t// syscall entry\n\tSYSCALL\n\tMOVV\tR4, r1+32(FP)\n\tMOVV\tR5, r2+40(FP)\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R11\t// syscall entry\n\tSYSCALL\n\tMOVV\tR4, r1+32(FP)\n\tMOVV\tR5, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_mips64x.s",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (mips64 || mips64le) && gc\n// +build linux\n// +build mips64 mips64le\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for mips64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tJAL\truntime·entersyscall(SB)\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVV\tR2, r1+32(FP)\n\tMOVV\tR3, r2+40(FP)\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVV\tR2, r1+32(FP)\n\tMOVV\tR3, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_mipsx.s",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (mips || mipsle) && gc\n// +build linux\n// +build mips mipsle\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for mips, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tJMP syscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tJMP syscall·Syscall6(SB)\n\nTEXT ·Syscall9(SB),NOSPLIT,$0-52\n\tJMP syscall·Syscall9(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tJAL\truntime·entersyscall(SB)\n\tMOVW\ta1+4(FP), R4\n\tMOVW\ta2+8(FP), R5\n\tMOVW\ta3+12(FP), R6\n\tMOVW\tR0, R7\n\tMOVW\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVW\tR2, r1+16(FP)\t// r1\n\tMOVW\tR3, r2+20(FP)\t// r2\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP syscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP syscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVW\ta1+4(FP), R4\n\tMOVW\ta2+8(FP), R5\n\tMOVW\ta3+12(FP), R6\n\tMOVW\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVW\tR2, r1+16(FP)\n\tMOVW\tR3, r2+20(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (ppc64 || ppc64le) && gc\n// +build linux\n// +build ppc64 ppc64le\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for ppc64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R3\n\tMOVD\ta2+16(FP), R4\n\tMOVD\ta3+24(FP), R5\n\tMOVD\tR0, R6\n\tMOVD\tR0, R7\n\tMOVD\tR0, R8\n\tMOVD\ttrap+0(FP), R9\t// syscall entry\n\tSYSCALL R9\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR4, r2+40(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R3\n\tMOVD\ta2+16(FP), R4\n\tMOVD\ta3+24(FP), R5\n\tMOVD\tR0, R6\n\tMOVD\tR0, R7\n\tMOVD\tR0, R8\n\tMOVD\ttrap+0(FP), R9\t// syscall entry\n\tSYSCALL R9\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR4, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_riscv64.s",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build riscv64 && gc\n// +build riscv64\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for linux/riscv64.\n//\n// Where available, just jump to package syscall's implementation of\n// these functions.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tCALL\truntime·entersyscall(SB)\n\tMOV\ta1+8(FP), A0\n\tMOV\ta2+16(FP), A1\n\tMOV\ta3+24(FP), A2\n\tMOV\ttrap+0(FP), A7\t// syscall entry\n\tECALL\n\tMOV\tA0, r1+32(FP)\t// r1\n\tMOV\tA1, r2+40(FP)\t// r2\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOV\ta1+8(FP), A0\n\tMOV\ta2+16(FP), A1\n\tMOV\ta3+24(FP), A2\n\tMOV\ttrap+0(FP), A7\t// syscall entry\n\tECALL\n\tMOV\tA0, r1+32(FP)\n\tMOV\tA1, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_s390x.s",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && s390x && gc\n// +build linux\n// +build s390x\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for s390x, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tBR\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tBR\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R2\n\tMOVD\ta2+16(FP), R3\n\tMOVD\ta3+24(FP), R4\n\tMOVD\t$0, R5\n\tMOVD\t$0, R6\n\tMOVD\t$0, R7\n\tMOVD\ttrap+0(FP), R1\t// syscall entry\n\tSYSCALL\n\tMOVD\tR2, r1+32(FP)\n\tMOVD\tR3, r2+40(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tBR\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tBR\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R2\n\tMOVD\ta2+16(FP), R3\n\tMOVD\ta3+24(FP), R4\n\tMOVD\t$0, R5\n\tMOVD\t$0, R6\n\tMOVD\t$0, R7\n\tMOVD\ttrap+0(FP), R1\t// syscall entry\n\tSYSCALL\n\tMOVD\tR2, r1+32(FP)\n\tMOVD\tR3, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System call support for mips64, OpenBSD\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_solaris_amd64.s",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n// +build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go\n//\n\nTEXT ·sysvicall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·sysvicall6(SB)\n\nTEXT ·rawSysvicall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·rawSysvicall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_zos_s390x.s",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x && gc\n// +build zos\n// +build s390x\n// +build gc\n\n#include \"textflag.h\"\n\n#define PSALAA 1208(R0)\n#define GTAB64(x) 80(x)\n#define LCA64(x) 88(x)\n#define CAA(x) 8(x)\n#define EDCHPXV(x) 1016(x) // in the CAA\n#define SAVSTACK_ASYNC(x) 336(x) // in the LCA\n\n// SS_*, where x=SAVSTACK_ASYNC\n#define SS_LE(x) 0(x)\n#define SS_GO(x) 8(x)\n#define SS_ERRNO(x) 16(x)\n#define SS_ERRNOJR(x) 20(x)\n\n#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6\n\nTEXT ·clearErrno(SB),NOSPLIT,$0-0\n\tBL\taddrerrno<>(SB)\n\tMOVD\t$0, 0(R3)\n\tRET\n\n// Returns the address of errno in R3.\nTEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get __errno FuncDesc.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tADD\t$(0x156*16), R9\n\tLMG\t0(R9), R5, R6\n\n\t// Switch to saved LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call __errno function.\n\tLE_CALL\n\tNOPH\n\n\t// Switch back to Go stack.\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\tRET\n\nTEXT ·syscall_syscall(SB),NOSPLIT,$0-56\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR0, r2+40(FP)\n\tMOVD\tR0, err+48(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+48(FP)\ndone:\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR0, r2+40(FP)\n\tMOVD\tR0, err+48(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+48(FP)\ndone:\n\tRET\n\nTEXT ·syscall_syscall6(SB),NOSPLIT,$0-80\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+56(FP)\n\tMOVD\tR0, r2+64(FP)\n\tMOVD\tR0, err+72(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+72(FP)\ndone:\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+56(FP)\n\tMOVD\tR0, r2+64(FP)\n\tMOVD\tR0, err+72(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\t·rrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+72(FP)\ndone:\n\tRET\n\nTEXT ·syscall_syscall9(SB),NOSPLIT,$0\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\tMOVD\ta7+56(FP), R12\n\tMOVD\tR12, (2176+48)(R4)\n\tMOVD\ta8+64(FP), R12\n\tMOVD\tR12, (2176+56)(R4)\n\tMOVD\ta9+72(FP), R12\n\tMOVD\tR12, (2176+64)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+80(FP)\n\tMOVD\tR0, r2+88(FP)\n\tMOVD\tR0, err+96(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+96(FP)\ndone:\n BL\truntime·exitsyscall(SB)\n RET\n\nTEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\tMOVD\ta7+56(FP), R12\n\tMOVD\tR12, (2176+48)(R4)\n\tMOVD\ta8+64(FP), R12\n\tMOVD\tR12, (2176+56)(R4)\n\tMOVD\ta9+72(FP), R12\n\tMOVD\tR12, (2176+64)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+80(FP)\n\tMOVD\tR0, r2+88(FP)\n\tMOVD\tR0, err+96(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+96(FP)\ndone:\n\tRET\n\n// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)\nTEXT ·svcCall(SB),NOSPLIT,$0\n\tBL\truntime·save_g(SB) // Save g and stack pointer\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\tR15, 0(R9)\n\n\tMOVD\targv+8(FP), R1 // Move function arguments into registers\n\tMOVD\tdsa+16(FP), g\n\tMOVD\tfnptr+0(FP), R15\n\n\tBYTE\t$0x0D // Branch to function\n\tBYTE\t$0xEF\n\n\tBL\truntime·load_g(SB) // Restore g and stack pointer\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R15\n\n\tRET\n\n// func svcLoad(name *byte) unsafe.Pointer\nTEXT ·svcLoad(SB),NOSPLIT,$0\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\tname+0(FP), R0 // Move SVC args into registers\n\tMOVD\t$0x80000000, R1\n\tMOVD\t$0, R15\n\tBYTE\t$0x0A // SVC 08 LOAD\n\tBYTE\t$0x08\n\tMOVW\tR15, R3 // Save return code from SVC\n\tMOVD\tR2, R15 // Restore go stack pointer\n\tCMP\tR3, $0 // Check SVC return code\n\tBNE\terror\n\n\tMOVD\t$-2, R3 // Reset last bit of entry point to zero\n\tAND\tR0, R3\n\tMOVD\tR3, addr+8(FP) // Return entry point returned by SVC\n\tCMP\tR0, R3 // Check if last bit of entry point was set\n\tBNE\tdone\n\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\t$0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08)\n\tBYTE\t$0x0A // SVC 09 DELETE\n\tBYTE\t$0x09\n\tMOVD\tR2, R15 // Restore go stack pointer\n\nerror:\n\tMOVD\t$0, addr+8(FP) // Return 0 on failure\ndone:\n\tXOR\tR0, R0 // Reset r0 to 0\n\tRET\n\n// func svcUnload(name *byte, fnptr unsafe.Pointer) int64\nTEXT ·svcUnload(SB),NOSPLIT,$0\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\tname+0(FP), R0 // Move SVC args into registers\n\tMOVD\taddr+8(FP), R15\n\tBYTE\t$0x0A // SVC 09\n\tBYTE\t$0x09\n\tXOR\tR0, R0 // Reset r0 to 0\n\tMOVD\tR15, R1 // Save SVC return code\n\tMOVD\tR2, R15 // Restore go stack pointer\n\tMOVD\tR1, rc+0(FP) // Return SVC return code\n\tRET\n\n// func gettid() uint64\nTEXT ·gettid(SB), NOSPLIT, $0\n\t// Get library control area (LCA).\n\tMOVW PSALAA, R8\n\tMOVD LCA64(R8), R8\n\n\t// Get CEECAATHDID\n\tMOVD CAA(R8), R9\n\tMOVD 0x3D0(R9), R9\n\tMOVD R9, ret+0(FP)\n\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/bluetooth_linux.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Bluetooth sockets and messages\n\npackage unix\n\n// Bluetooth Protocols\nconst (\n\tBTPROTO_L2CAP = 0\n\tBTPROTO_HCI = 1\n\tBTPROTO_SCO = 2\n\tBTPROTO_RFCOMM = 3\n\tBTPROTO_BNEP = 4\n\tBTPROTO_CMTP = 5\n\tBTPROTO_HIDP = 6\n\tBTPROTO_AVDTP = 7\n)\n\nconst (\n\tHCI_CHANNEL_RAW = 0\n\tHCI_CHANNEL_USER = 1\n\tHCI_CHANNEL_MONITOR = 2\n\tHCI_CHANNEL_CONTROL = 3\n\tHCI_CHANNEL_LOGGING = 4\n)\n\n// Socketoption Level\nconst (\n\tSOL_BLUETOOTH = 0x112\n\tSOL_HCI = 0x0\n\tSOL_L2CAP = 0x6\n\tSOL_RFCOMM = 0x12\n\tSOL_SCO = 0x11\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/cap_freebsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build freebsd\n// +build freebsd\n\npackage unix\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\n// Go implementation of C mostly found in /usr/src/sys/kern/subr_capability.c\n\nconst (\n\t// This is the version of CapRights this package understands. See C implementation for parallels.\n\tcapRightsGoVersion = CAP_RIGHTS_VERSION_00\n\tcapArSizeMin = CAP_RIGHTS_VERSION_00 + 2\n\tcapArSizeMax = capRightsGoVersion + 2\n)\n\nvar (\n\tbit2idx = []int{\n\t\t-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,\n\t\t4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n\t}\n)\n\nfunc capidxbit(right uint64) int {\n\treturn int((right >> 57) & 0x1f)\n}\n\nfunc rightToIndex(right uint64) (int, error) {\n\tidx := capidxbit(right)\n\tif idx < 0 || idx >= len(bit2idx) {\n\t\treturn -2, fmt.Errorf(\"index for right 0x%x out of range\", right)\n\t}\n\treturn bit2idx[idx], nil\n}\n\nfunc caprver(right uint64) int {\n\treturn int(right >> 62)\n}\n\nfunc capver(rights *CapRights) int {\n\treturn caprver(rights.Rights[0])\n}\n\nfunc caparsize(rights *CapRights) int {\n\treturn capver(rights) + 2\n}\n\n// CapRightsSet sets the permissions in setrights in rights.\nfunc CapRightsSet(rights *CapRights, setrights []uint64) error {\n\t// This is essentially a copy of cap_rights_vset()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range setrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch\")\n\t\t}\n\t\trights.Rights[i] |= right\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch (after assign)\")\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// CapRightsClear clears the permissions in clearrights from rights.\nfunc CapRightsClear(rights *CapRights, clearrights []uint64) error {\n\t// This is essentially a copy of cap_rights_vclear()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range clearrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch\")\n\t\t}\n\t\trights.Rights[i] &= ^(right & 0x01FFFFFFFFFFFFFF)\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch (after assign)\")\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// CapRightsIsSet checks whether all the permissions in setrights are present in rights.\nfunc CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) {\n\t// This is essentially a copy of cap_rights_is_vset()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn false, fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn false, errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range setrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn false, errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn false, err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn false, errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn false, errors.New(\"index mismatch\")\n\t\t}\n\t\tif (rights.Rights[i] & right) != right {\n\t\t\treturn false, nil\n\t\t}\n\t}\n\n\treturn true, nil\n}\n\nfunc capright(idx uint64, bit uint64) uint64 {\n\treturn ((1 << (57 + idx)) | bit)\n}\n\n// CapRightsInit returns a pointer to an initialised CapRights structure filled with rights.\n// See man cap_rights_init(3) and rights(4).\nfunc CapRightsInit(rights []uint64) (*CapRights, error) {\n\tvar r CapRights\n\tr.Rights[0] = (capRightsGoVersion << 62) | capright(0, 0)\n\tr.Rights[1] = capright(1, 0)\n\n\terr := CapRightsSet(&r, rights)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn &r, nil\n}\n\n// CapRightsLimit reduces the operations permitted on fd to at most those contained in rights.\n// The capability rights on fd can never be increased by CapRightsLimit.\n// See man cap_rights_limit(2) and rights(4).\nfunc CapRightsLimit(fd uintptr, rights *CapRights) error {\n\treturn capRightsLimit(int(fd), rights)\n}\n\n// CapRightsGet returns a CapRights structure containing the operations permitted on fd.\n// See man cap_rights_get(3) and rights(4).\nfunc CapRightsGet(fd uintptr) (*CapRights, error) {\n\tr, err := CapRightsInit(nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\terr = capRightsGet(capRightsGoVersion, int(fd), r)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn r, nil\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/constants.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos\n\npackage unix\n\nconst (\n\tR_OK = 0x4\n\tW_OK = 0x2\n\tX_OK = 0x1\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_aix_ppc.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix && ppc\n// +build aix,ppc\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by AIX.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 16) & 0xffff)\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff)\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn uint64(((major) << 16) | (minor))\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_aix_ppc64.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix && ppc64\n// +build aix,ppc64\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used AIX.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x3fffffff00000000) >> 32)\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32((dev & 0x00000000ffffffff) >> 0)\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tvar DEVNO64 uint64\n\tDEVNO64 = 0x8000000000000000\n\treturn ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_darwin.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in Darwin's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of a Darwin device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 24) & 0xff)\n}\n\n// Minor returns the minor component of a Darwin device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffffff)\n}\n\n// Mkdev returns a Darwin device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 24) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_dragonfly.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in Dragonfly's sys/types.h header.\n//\n// The information below is extracted and adapted from sys/types.h:\n//\n// Minor gives a cookie instead of an index since in order to avoid changing the\n// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for\n// devices that don't use them.\n\npackage unix\n\n// Major returns the major component of a DragonFlyBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 8) & 0xff)\n}\n\n// Minor returns the minor component of a DragonFlyBSD device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff00ff)\n}\n\n// Mkdev returns a DragonFlyBSD device number generated from the given major and\n// minor components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 8) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_freebsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in FreeBSD's sys/types.h header.\n//\n// The information below is extracted and adapted from sys/types.h:\n//\n// Minor gives a cookie instead of an index since in order to avoid changing the\n// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for\n// devices that don't use them.\n\npackage unix\n\n// Major returns the major component of a FreeBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 8) & 0xff)\n}\n\n// Minor returns the minor component of a FreeBSD device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff00ff)\n}\n\n// Mkdev returns a FreeBSD device number generated from the given major and\n// minor components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 8) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_linux.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by the Linux kernel and glibc.\n//\n// The information below is extracted and adapted from bits/sysmacros.h in the\n// glibc sources:\n//\n// dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's\n// default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major\n// number and m is a hex digit of the minor number. This is backward compatible\n// with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also\n// backward compatible with the Linux kernel, which for some architectures uses\n// 32-bit dev_t, encoded as mmmM MMmm.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\tmajor := uint32((dev & 0x00000000000fff00) >> 8)\n\tmajor |= uint32((dev & 0xfffff00000000000) >> 32)\n\treturn major\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x00000000000000ff) >> 0)\n\tminor |= uint32((dev & 0x00000ffffff00000) >> 12)\n\treturn minor\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) & 0x00000fff) << 8\n\tdev |= (uint64(major) & 0xfffff000) << 32\n\tdev |= (uint64(minor) & 0x000000ff) << 0\n\tdev |= (uint64(minor) & 0xffffff00) << 12\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_netbsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in NetBSD's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of a NetBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x000fff00) >> 8)\n}\n\n// Minor returns the minor component of a NetBSD device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x000000ff) >> 0)\n\tminor |= uint32((dev & 0xfff00000) >> 12)\n\treturn minor\n}\n\n// Mkdev returns a NetBSD device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) << 8) & 0x000fff00\n\tdev |= (uint64(minor) << 12) & 0xfff00000\n\tdev |= (uint64(minor) << 0) & 0x000000ff\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_openbsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in OpenBSD's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of an OpenBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x0000ff00) >> 8)\n}\n\n// Minor returns the minor component of an OpenBSD device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x000000ff) >> 0)\n\tminor |= uint32((dev & 0xffff0000) >> 8)\n\treturn minor\n}\n\n// Mkdev returns an OpenBSD device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) << 8) & 0x0000ff00\n\tdev |= (uint64(minor) << 8) & 0xffff0000\n\tdev |= (uint64(minor) << 0) & 0x000000ff\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n// +build zos,s390x\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by z/OS.\n//\n// The information below is extracted and adapted from macros.\n\npackage unix\n\n// Major returns the major component of a z/OS device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 16) & 0x0000FFFF)\n}\n\n// Minor returns the minor component of a z/OS device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0x0000FFFF)\n}\n\n// Mkdev returns a z/OS device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 16) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dirent.go",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris\n\npackage unix\n\nimport \"unsafe\"\n\n// readInt returns the size-bytes unsigned integer in native byte order at offset off.\nfunc readInt(b []byte, off, size uintptr) (u uint64, ok bool) {\n\tif len(b) < int(off+size) {\n\t\treturn 0, false\n\t}\n\tif isBigEndian {\n\t\treturn readIntBE(b[off:], size), true\n\t}\n\treturn readIntLE(b[off:], size), true\n}\n\nfunc readIntBE(b []byte, size uintptr) uint64 {\n\tswitch size {\n\tcase 1:\n\t\treturn uint64(b[0])\n\tcase 2:\n\t\t_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[1]) | uint64(b[0])<<8\n\tcase 4:\n\t\t_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[3]) | uint64(b[2])<<8 | uint64(b[1])<<16 | uint64(b[0])<<24\n\tcase 8:\n\t\t_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |\n\t\t\tuint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56\n\tdefault:\n\t\tpanic(\"syscall: readInt with unsupported size\")\n\t}\n}\n\nfunc readIntLE(b []byte, size uintptr) uint64 {\n\tswitch size {\n\tcase 1:\n\t\treturn uint64(b[0])\n\tcase 2:\n\t\t_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8\n\tcase 4:\n\t\t_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24\n\tcase 8:\n\t\t_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |\n\t\t\tuint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56\n\tdefault:\n\t\tpanic(\"syscall: readInt with unsupported size\")\n\t}\n}\n\n// ParseDirent parses up to max directory entries in buf,\n// appending the names to names. It returns the number of\n// bytes consumed from buf, the number of entries added\n// to names, and the new names slice.\nfunc ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {\n\toriglen := len(buf)\n\tcount = 0\n\tfor max != 0 && len(buf) > 0 {\n\t\treclen, ok := direntReclen(buf)\n\t\tif !ok || reclen > uint64(len(buf)) {\n\t\t\treturn origlen, count, names\n\t\t}\n\t\trec := buf[:reclen]\n\t\tbuf = buf[reclen:]\n\t\tino, ok := direntIno(rec)\n\t\tif !ok {\n\t\t\tbreak\n\t\t}\n\t\tif ino == 0 { // File absent in directory.\n\t\t\tcontinue\n\t\t}\n\t\tconst namoff = uint64(unsafe.Offsetof(Dirent{}.Name))\n\t\tnamlen, ok := direntNamlen(rec)\n\t\tif !ok || namoff+namlen > uint64(len(rec)) {\n\t\t\tbreak\n\t\t}\n\t\tname := rec[namoff : namoff+namlen]\n\t\tfor i, c := range name {\n\t\t\tif c == 0 {\n\t\t\t\tname = name[:i]\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Check for useless names before allocating a string.\n\t\tif string(name) == \".\" || string(name) == \"..\" {\n\t\t\tcontinue\n\t\t}\n\t\tmax--\n\t\tcount++\n\t\tnames = append(names, string(name))\n\t}\n\treturn origlen - len(buf), count, names\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/endian_big.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n//\n//go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64\n// +build armbe arm64be m68k mips mips64 mips64p32 ppc ppc64 s390 s390x shbe sparc sparc64\n\npackage unix\n\nconst isBigEndian = true\n"
},
{
"path": "vendor/golang.org/x/sys/unix/endian_little.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n//\n//go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh\n// +build 386 amd64 amd64p32 alpha arm arm64 loong64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh\n\npackage unix\n\nconst isBigEndian = false\n"
},
{
"path": "vendor/golang.org/x/sys/unix/env_unix.go",
"content": "// Copyright 2010 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos\n\n// Unix environment variables.\n\npackage unix\n\nimport \"syscall\"\n\nfunc Getenv(key string) (value string, found bool) {\n\treturn syscall.Getenv(key)\n}\n\nfunc Setenv(key, value string) error {\n\treturn syscall.Setenv(key, value)\n}\n\nfunc Clearenv() {\n\tsyscall.Clearenv()\n}\n\nfunc Environ() []string {\n\treturn syscall.Environ()\n}\n\nfunc Unsetenv(key string) error {\n\treturn syscall.Unsetenv(key)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/epoll_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n// +build zos,s390x\n\npackage unix\n\nimport (\n\t\"sync\"\n)\n\n// This file simulates epoll on z/OS using poll.\n\n// Analogous to epoll_event on Linux.\n// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?\ntype EpollEvent struct {\n\tEvents uint32\n\tFd int32\n\tPad int32\n}\n\nconst (\n\tEPOLLERR = 0x8\n\tEPOLLHUP = 0x10\n\tEPOLLIN = 0x1\n\tEPOLLMSG = 0x400\n\tEPOLLOUT = 0x4\n\tEPOLLPRI = 0x2\n\tEPOLLRDBAND = 0x80\n\tEPOLLRDNORM = 0x40\n\tEPOLLWRBAND = 0x200\n\tEPOLLWRNORM = 0x100\n\tEPOLL_CTL_ADD = 0x1\n\tEPOLL_CTL_DEL = 0x2\n\tEPOLL_CTL_MOD = 0x3\n\t// The following constants are part of the epoll API, but represent\n\t// currently unsupported functionality on z/OS.\n\t// EPOLL_CLOEXEC = 0x80000\n\t// EPOLLET = 0x80000000\n\t// EPOLLONESHOT = 0x40000000\n\t// EPOLLRDHUP = 0x2000 // Typically used with edge-triggered notis\n\t// EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode\n\t// EPOLLWAKEUP = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability\n)\n\n// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL\n// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).\n\n// epToPollEvt converts epoll event field to poll equivalent.\n// In epoll, Events is a 32-bit field, while poll uses 16 bits.\nfunc epToPollEvt(events uint32) int16 {\n\tvar ep2p = map[uint32]int16{\n\t\tEPOLLIN: POLLIN,\n\t\tEPOLLOUT: POLLOUT,\n\t\tEPOLLHUP: POLLHUP,\n\t\tEPOLLPRI: POLLPRI,\n\t\tEPOLLERR: POLLERR,\n\t}\n\n\tvar pollEvts int16 = 0\n\tfor epEvt, pEvt := range ep2p {\n\t\tif (events & epEvt) != 0 {\n\t\t\tpollEvts |= pEvt\n\t\t}\n\t}\n\n\treturn pollEvts\n}\n\n// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.\nfunc pToEpollEvt(revents int16) uint32 {\n\tvar p2ep = map[int16]uint32{\n\t\tPOLLIN: EPOLLIN,\n\t\tPOLLOUT: EPOLLOUT,\n\t\tPOLLHUP: EPOLLHUP,\n\t\tPOLLPRI: EPOLLPRI,\n\t\tPOLLERR: EPOLLERR,\n\t}\n\n\tvar epollEvts uint32 = 0\n\tfor pEvt, epEvt := range p2ep {\n\t\tif (revents & pEvt) != 0 {\n\t\t\tepollEvts |= epEvt\n\t\t}\n\t}\n\n\treturn epollEvts\n}\n\n// Per-process epoll implementation.\ntype epollImpl struct {\n\tmu sync.Mutex\n\tepfd2ep map[int]*eventPoll\n\tnextEpfd int\n}\n\n// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.\n// On Linux, this is an in-kernel data structure accessed through a fd.\ntype eventPoll struct {\n\tmu sync.Mutex\n\tfds map[int]*EpollEvent\n}\n\n// epoll impl for this process.\nvar impl epollImpl = epollImpl{\n\tepfd2ep: make(map[int]*eventPoll),\n\tnextEpfd: 0,\n}\n\nfunc (e *epollImpl) epollcreate(size int) (epfd int, err error) {\n\te.mu.Lock()\n\tdefer e.mu.Unlock()\n\tepfd = e.nextEpfd\n\te.nextEpfd++\n\n\te.epfd2ep[epfd] = &eventPoll{\n\t\tfds: make(map[int]*EpollEvent),\n\t}\n\treturn epfd, nil\n}\n\nfunc (e *epollImpl) epollcreate1(flag int) (fd int, err error) {\n\treturn e.epollcreate(4)\n}\n\nfunc (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {\n\te.mu.Lock()\n\tdefer e.mu.Unlock()\n\n\tep, ok := e.epfd2ep[epfd]\n\tif !ok {\n\n\t\treturn EBADF\n\t}\n\n\tswitch op {\n\tcase EPOLL_CTL_ADD:\n\t\t// TODO(neeilan): When we make epfds and fds disjoint, detect epoll\n\t\t// loops here (instances watching each other) and return ELOOP.\n\t\tif _, ok := ep.fds[fd]; ok {\n\t\t\treturn EEXIST\n\t\t}\n\t\tep.fds[fd] = event\n\tcase EPOLL_CTL_MOD:\n\t\tif _, ok := ep.fds[fd]; !ok {\n\t\t\treturn ENOENT\n\t\t}\n\t\tep.fds[fd] = event\n\tcase EPOLL_CTL_DEL:\n\t\tif _, ok := ep.fds[fd]; !ok {\n\t\t\treturn ENOENT\n\t\t}\n\t\tdelete(ep.fds, fd)\n\n\t}\n\treturn nil\n}\n\n// Must be called while holding ep.mu\nfunc (ep *eventPoll) getFds() []int {\n\tfds := make([]int, len(ep.fds))\n\tfor fd := range ep.fds {\n\t\tfds = append(fds, fd)\n\t}\n\treturn fds\n}\n\nfunc (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {\n\te.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait\n\tep, ok := e.epfd2ep[epfd]\n\n\tif !ok {\n\t\te.mu.Unlock()\n\t\treturn 0, EBADF\n\t}\n\n\tpollfds := make([]PollFd, 4)\n\tfor fd, epollevt := range ep.fds {\n\t\tpollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})\n\t}\n\te.mu.Unlock()\n\n\tn, err = Poll(pollfds, msec)\n\tif err != nil {\n\t\treturn n, err\n\t}\n\n\ti := 0\n\tfor _, pFd := range pollfds {\n\t\tif pFd.Revents != 0 {\n\t\t\tevents[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}\n\t\t\ti++\n\t\t}\n\n\t\tif i == n {\n\t\t\tbreak\n\t\t}\n\t}\n\n\treturn n, nil\n}\n\nfunc EpollCreate(size int) (fd int, err error) {\n\treturn impl.epollcreate(size)\n}\n\nfunc EpollCreate1(flag int) (fd int, err error) {\n\treturn impl.epollcreate1(flag)\n}\n\nfunc EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {\n\treturn impl.epollctl(epfd, op, fd, event)\n}\n\n// Because EpollWait mutates events, the caller is expected to coordinate\n// concurrent access if calling with the same epfd from multiple goroutines.\nfunc EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {\n\treturn impl.epollwait(epfd, events, msec)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/errors_freebsd_386.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Constants that were deprecated or moved to enums in the FreeBSD headers. Keep\n// them here for backwards compatibility.\n\npackage unix\n\nconst (\n\tDLT_HHDLC = 0x79\n\tIFF_SMART = 0x20\n\tIFT_1822 = 0x2\n\tIFT_A12MPPSWITCH = 0x82\n\tIFT_AAL2 = 0xbb\n\tIFT_AAL5 = 0x31\n\tIFT_ADSL = 0x5e\n\tIFT_AFLANE8023 = 0x3b\n\tIFT_AFLANE8025 = 0x3c\n\tIFT_ARAP = 0x58\n\tIFT_ARCNET = 0x23\n\tIFT_ARCNETPLUS = 0x24\n\tIFT_ASYNC = 0x54\n\tIFT_ATM = 0x25\n\tIFT_ATMDXI = 0x69\n\tIFT_ATMFUNI = 0x6a\n\tIFT_ATMIMA = 0x6b\n\tIFT_ATMLOGICAL = 0x50\n\tIFT_ATMRADIO = 0xbd\n\tIFT_ATMSUBINTERFACE = 0x86\n\tIFT_ATMVCIENDPT = 0xc2\n\tIFT_ATMVIRTUAL = 0x95\n\tIFT_BGPPOLICYACCOUNTING = 0xa2\n\tIFT_BSC = 0x53\n\tIFT_CCTEMUL = 0x3d\n\tIFT_CEPT = 0x13\n\tIFT_CES = 0x85\n\tIFT_CHANNEL = 0x46\n\tIFT_CNR = 0x55\n\tIFT_COFFEE = 0x84\n\tIFT_COMPOSITELINK = 0x9b\n\tIFT_DCN = 0x8d\n\tIFT_DIGITALPOWERLINE = 0x8a\n\tIFT_DIGITALWRAPPEROVERHEADCHANNEL = 0xba\n\tIFT_DLSW = 0x4a\n\tIFT_DOCSCABLEDOWNSTREAM = 0x80\n\tIFT_DOCSCABLEMACLAYER = 0x7f\n\tIFT_DOCSCABLEUPSTREAM = 0x81\n\tIFT_DS0 = 0x51\n\tIFT_DS0BUNDLE = 0x52\n\tIFT_DS1FDL = 0xaa\n\tIFT_DS3 = 0x1e\n\tIFT_DTM = 0x8c\n\tIFT_DVBASILN = 0xac\n\tIFT_DVBASIOUT = 0xad\n\tIFT_DVBRCCDOWNSTREAM = 0x93\n\tIFT_DVBRCCMACLAYER = 0x92\n\tIFT_DVBRCCUPSTREAM = 0x94\n\tIFT_ENC = 0xf4\n\tIFT_EON = 0x19\n\tIFT_EPLRS = 0x57\n\tIFT_ESCON = 0x49\n\tIFT_ETHER = 0x6\n\tIFT_FAITH = 0xf2\n\tIFT_FAST = 0x7d\n\tIFT_FASTETHER = 0x3e\n\tIFT_FASTETHERFX = 0x45\n\tIFT_FDDI = 0xf\n\tIFT_FIBRECHANNEL = 0x38\n\tIFT_FRAMERELAYINTERCONNECT = 0x3a\n\tIFT_FRAMERELAYMPI = 0x5c\n\tIFT_FRDLCIENDPT = 0xc1\n\tIFT_FRELAY = 0x20\n\tIFT_FRELAYDCE = 0x2c\n\tIFT_FRF16MFRBUNDLE = 0xa3\n\tIFT_FRFORWARD = 0x9e\n\tIFT_G703AT2MB = 0x43\n\tIFT_G703AT64K = 0x42\n\tIFT_GIF = 0xf0\n\tIFT_GIGABITETHERNET = 0x75\n\tIFT_GR303IDT = 0xb2\n\tIFT_GR303RDT = 0xb1\n\tIFT_H323GATEKEEPER = 0xa4\n\tIFT_H323PROXY = 0xa5\n\tIFT_HDH1822 = 0x3\n\tIFT_HDLC = 0x76\n\tIFT_HDSL2 = 0xa8\n\tIFT_HIPERLAN2 = 0xb7\n\tIFT_HIPPI = 0x2f\n\tIFT_HIPPIINTERFACE = 0x39\n\tIFT_HOSTPAD = 0x5a\n\tIFT_HSSI = 0x2e\n\tIFT_HY = 0xe\n\tIFT_IBM370PARCHAN = 0x48\n\tIFT_IDSL = 0x9a\n\tIFT_IEEE80211 = 0x47\n\tIFT_IEEE80212 = 0x37\n\tIFT_IEEE8023ADLAG = 0xa1\n\tIFT_IFGSN = 0x91\n\tIFT_IMT = 0xbe\n\tIFT_INTERLEAVE = 0x7c\n\tIFT_IP = 0x7e\n\tIFT_IPFORWARD = 0x8e\n\tIFT_IPOVERATM = 0x72\n\tIFT_IPOVERCDLC = 0x6d\n\tIFT_IPOVERCLAW = 0x6e\n\tIFT_IPSWITCH = 0x4e\n\tIFT_IPXIP = 0xf9\n\tIFT_ISDN = 0x3f\n\tIFT_ISDNBASIC = 0x14\n\tIFT_ISDNPRIMARY = 0x15\n\tIFT_ISDNS = 0x4b\n\tIFT_ISDNU = 0x4c\n\tIFT_ISO88022LLC = 0x29\n\tIFT_ISO88023 = 0x7\n\tIFT_ISO88024 = 0x8\n\tIFT_ISO88025 = 0x9\n\tIFT_ISO88025CRFPINT = 0x62\n\tIFT_ISO88025DTR = 0x56\n\tIFT_ISO88025FIBER = 0x73\n\tIFT_ISO88026 = 0xa\n\tIFT_ISUP = 0xb3\n\tIFT_L3IPXVLAN = 0x89\n\tIFT_LAPB = 0x10\n\tIFT_LAPD = 0x4d\n\tIFT_LAPF = 0x77\n\tIFT_LOCALTALK = 0x2a\n\tIFT_LOOP = 0x18\n\tIFT_MEDIAMAILOVERIP = 0x8b\n\tIFT_MFSIGLINK = 0xa7\n\tIFT_MIOX25 = 0x26\n\tIFT_MODEM = 0x30\n\tIFT_MPC = 0x71\n\tIFT_MPLS = 0xa6\n\tIFT_MPLSTUNNEL = 0x96\n\tIFT_MSDSL = 0x8f\n\tIFT_MVL = 0xbf\n\tIFT_MYRINET = 0x63\n\tIFT_NFAS = 0xaf\n\tIFT_NSIP = 0x1b\n\tIFT_OPTICALCHANNEL = 0xc3\n\tIFT_OPTICALTRANSPORT = 0xc4\n\tIFT_OTHER = 0x1\n\tIFT_P10 = 0xc\n\tIFT_P80 = 0xd\n\tIFT_PARA = 0x22\n\tIFT_PFLOG = 0xf6\n\tIFT_PFSYNC = 0xf7\n\tIFT_PLC = 0xae\n\tIFT_POS = 0xab\n\tIFT_PPPMULTILINKBUNDLE = 0x6c\n\tIFT_PROPBWAP2MP = 0xb8\n\tIFT_PROPCNLS = 0x59\n\tIFT_PROPDOCSWIRELESSDOWNSTREAM = 0xb5\n\tIFT_PROPDOCSWIRELESSMACLAYER = 0xb4\n\tIFT_PROPDOCSWIRELESSUPSTREAM = 0xb6\n\tIFT_PROPMUX = 0x36\n\tIFT_PROPWIRELESSP2P = 0x9d\n\tIFT_PTPSERIAL = 0x16\n\tIFT_PVC = 0xf1\n\tIFT_QLLC = 0x44\n\tIFT_RADIOMAC = 0xbc\n\tIFT_RADSL = 0x5f\n\tIFT_REACHDSL = 0xc0\n\tIFT_RFC1483 = 0x9f\n\tIFT_RS232 = 0x21\n\tIFT_RSRB = 0x4f\n\tIFT_SDLC = 0x11\n\tIFT_SDSL = 0x60\n\tIFT_SHDSL = 0xa9\n\tIFT_SIP = 0x1f\n\tIFT_SLIP = 0x1c\n\tIFT_SMDSDXI = 0x2b\n\tIFT_SMDSICIP = 0x34\n\tIFT_SONET = 0x27\n\tIFT_SONETOVERHEADCHANNEL = 0xb9\n\tIFT_SONETPATH = 0x32\n\tIFT_SONETVT = 0x33\n\tIFT_SRP = 0x97\n\tIFT_SS7SIGLINK = 0x9c\n\tIFT_STACKTOSTACK = 0x6f\n\tIFT_STARLAN = 0xb\n\tIFT_STF = 0xd7\n\tIFT_T1 = 0x12\n\tIFT_TDLC = 0x74\n\tIFT_TERMPAD = 0x5b\n\tIFT_TR008 = 0xb0\n\tIFT_TRANSPHDLC = 0x7b\n\tIFT_TUNNEL = 0x83\n\tIFT_ULTRA = 0x1d\n\tIFT_USB = 0xa0\n\tIFT_V11 = 0x40\n\tIFT_V35 = 0x2d\n\tIFT_V36 = 0x41\n\tIFT_V37 = 0x78\n\tIFT_VDSL = 0x61\n\tIFT_VIRTUALIPADDRESS = 0x70\n\tIFT_VOICEEM = 0x64\n\tIFT_VOICEENCAP = 0x67\n\tIFT_VOICEFXO = 0x65\n\tIFT_VOICEFXS = 0x66\n\tIFT_VOICEOVERATM = 0x98\n\tIFT_VOICEOVERFRAMERELAY = 0x99\n\tIFT_VOICEOVERIP = 0x68\n\tIFT_X213 = 0x5d\n\tIFT_X25 = 0x5\n\tIFT_X25DDN = 0x4\n\tIFT_X25HUNTGROUP = 0x7a\n\tIFT_X25MLP = 0x79\n\tIFT_X25PLE = 0x28\n\tIFT_XETHER = 0x1a\n\tIPPROTO_MAXID = 0x34\n\tIPV6_FAITH = 0x1d\n\tIPV6_MIN_MEMBERSHIPS = 0x1f\n\tIP_FAITH = 0x16\n\tIP_MAX_SOURCE_FILTER = 0x400\n\tIP_MIN_MEMBERSHIPS = 0x1f\n\tMAP_NORESERVE = 0x40\n\tMAP_RENAME = 0x20\n\tNET_RT_MAXID = 0x6\n\tRTF_PRCLONING = 0x10000\n\tRTM_OLDADD = 0x9\n\tRTM_OLDDEL = 0xa\n\tRT_CACHING_CONTEXT = 0x1\n\tRT_NORTREF = 0x2\n\tSIOCADDRT = 0x8030720a\n\tSIOCALIFADDR = 0x8118691b\n\tSIOCDELRT = 0x8030720b\n\tSIOCDLIFADDR = 0x8118691d\n\tSIOCGLIFADDR = 0xc118691c\n\tSIOCGLIFPHYADDR = 0xc118694b\n\tSIOCSLIFPHYADDR = 0x8118694a\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/errors_freebsd_amd64.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Constants that were deprecated or moved to enums in the FreeBSD headers. Keep\n// them here for backwards compatibility.\n\npackage unix\n\nconst (\n\tDLT_HHDLC = 0x79\n\tIFF_SMART = 0x20\n\tIFT_1822 = 0x2\n\tIFT_A12MPPSWITCH = 0x82\n\tIFT_AAL2 = 0xbb\n\tIFT_AAL5 = 0x31\n\tIFT_ADSL = 0x5e\n\tIFT_AFLANE8023 = 0x3b\n\tIFT_AFLANE8025 = 0x3c\n\tIFT_ARAP = 0x58\n\tIFT_ARCNET = 0x23\n\tIFT_ARCNETPLUS = 0x24\n\tIFT_ASYNC = 0x54\n\tIFT_ATM = 0x25\n\tIFT_ATMDXI = 0x69\n\tIFT_ATMFUNI = 0x6a\n\tIFT_ATMIMA = 0x6b\n\tIFT_ATMLOGICAL = 0x50\n\tIFT_ATMRADIO = 0xbd\n\tIFT_ATMSUBINTERFACE = 0x86\n\tIFT_ATMVCIENDPT = 0xc2\n\tIFT_ATMVIRTUAL = 0x95\n\tIFT_BGPPOLICYACCOUNTING = 0xa2\n\tIFT_BSC = 0x53\n\tIFT_CCTEMUL = 0x3d\n\tIFT_CEPT = 0x13\n\tIFT_CES = 0x85\n\tIFT_CHANNEL = 0x46\n\tIFT_CNR = 0x55\n\tIFT_COFFEE = 0x84\n\tIFT_COMPOSITELINK = 0x9b\n\tIFT_DCN = 0x8d\n\tIFT_DIGITALPOWERLINE = 0x8a\n\tIFT_DIGITALWRAPPEROVERHEADCHANNEL = 0xba\n\tIFT_DLSW = 0x4a\n\tIFT_DOCSCABLEDOWNSTREAM = 0x80\n\tIFT_DOCSCABLEMACLAYER = 0x7f\n\tIFT_DOCSCABLEUPSTREAM = 0x81\n\tIFT_DS0 = 0x51\n\tIFT_DS0BUNDLE = 0x52\n\tIFT_DS1FDL = 0xaa\n\tIFT_DS3 = 0x1e\n\tIFT_DTM = 0x8c\n\tIFT_DVBASILN = 0xac\n\tIFT_DVBASIOUT = 0xad\n\tIFT_DVBRCCDOWNSTREAM = 0x93\n\tIFT_DVBRCCMACLAYER = 0x92\n\tIFT_DVBRCCUPSTREAM = 0x94\n\tIFT_ENC = 0xf4\n\tIFT_EON = 0x19\n\tIFT_EPLRS = 0x57\n\tIFT_ESCON = 0x49\n\tIFT_ETHER = 0x6\n\tIFT_FAITH = 0xf2\n\tIFT_FAST = 0x7d\n\tIFT_FASTETHER = 0x3e\n\tIFT_FASTETHERFX = 0x45\n\tIFT_FDDI = 0xf\n\tIFT_FIBRECHANNEL = 0x38\n\tIFT_FRAMERELAYINTERCONNECT = 0x3a\n\tIFT_FRAMERELAYMPI = 0x5c\n\tIFT_FRDLCIENDPT = 0xc1\n\tIFT_FRELAY = 0x20\n\tIFT_FRELAYDCE = 0x2c\n\tIFT_FRF16MFRBUNDLE = 0xa3\n\tIFT_FRFORWARD = 0x9e\n\tIFT_G703AT2MB = 0x43\n\tIFT_G703AT64K = 0x42\n\tIFT_GIF = 0xf0\n\tIFT_GIGABITETHERNET = 0x75\n\tIFT_GR303IDT = 0xb2\n\tIFT_GR303RDT = 0xb1\n\tIFT_H323GATEKEEPER = 0xa4\n\tIFT_H323PROXY = 0xa5\n\tIFT_HDH1822 = 0x3\n\tIFT_HDLC = 0x76\n\tIFT_HDSL2 = 0xa8\n\tIFT_HIPERLAN2 = 0xb7\n\tIFT_HIPPI = 0x2f\n\tIFT_HIPPIINTERFACE = 0x39\n\tIFT_HOSTPAD = 0x5a\n\tIFT_HSSI = 0x2e\n\tIFT_HY = 0xe\n\tIFT_IBM370PARCHAN = 0x48\n\tIFT_IDSL = 0x9a\n\tIFT_IEEE80211 = 0x47\n\tIFT_IEEE80212 = 0x37\n\tIFT_IEEE8023ADLAG = 0xa1\n\tIFT_IFGSN = 0x91\n\tIFT_IMT = 0xbe\n\tIFT_INTERLEAVE = 0x7c\n\tIFT_IP = 0x7e\n\tIFT_IPFORWARD = 0x8e\n\tIFT_IPOVERATM = 0x72\n\tIFT_IPOVERCDLC = 0x6d\n\tIFT_IPOVERCLAW = 0x6e\n\tIFT_IPSWITCH = 0x4e\n\tIFT_IPXIP = 0xf9\n\tIFT_ISDN = 0x3f\n\tIFT_ISDNBASIC = 0x14\n\tIFT_ISDNPRIMARY = 0x15\n\tIFT_ISDNS = 0x4b\n\tIFT_ISDNU = 0x4c\n\tIFT_ISO88022LLC = 0x29\n\tIFT_ISO88023 = 0x7\n\tIFT_ISO88024 = 0x8\n\tIFT_ISO88025 = 0x9\n\tIFT_ISO88025CRFPINT = 0x62\n\tIFT_ISO88025DTR = 0x56\n\tIFT_ISO88025FIBER = 0x73\n\tIFT_ISO88026 = 0xa\n\tIFT_ISUP = 0xb3\n\tIFT_L3IPXVLAN = 0x89\n\tIFT_LAPB = 0x10\n\tIFT_LAPD = 0x4d\n\tIFT_LAPF = 0x77\n\tIFT_LOCALTALK = 0x2a\n\tIFT_LOOP = 0x18\n\tIFT_MEDIAMAILOVERIP = 0x8b\n\tIFT_MFSIGLINK = 0xa7\n\tIFT_MIOX25 = 0x26\n\tIFT_MODEM = 0x30\n\tIFT_MPC = 0x71\n\tIFT_MPLS = 0xa6\n\tIFT_MPLSTUNNEL = 0x96\n\tIFT_MSDSL = 0x8f\n\tIFT_MVL = 0xbf\n\tIFT_MYRINET = 0x63\n\tIFT_NFAS = 0xaf\n\tIFT_NSIP = 0x1b\n\tIFT_OPTICALCHANNEL = 0xc3\n\tIFT_OPTICALTRANSPORT = 0xc4\n\tIFT_OTHER = 0x1\n\tIFT_P10 = 0xc\n\tIFT_P80 = 0xd\n\tIFT_PARA = 0x22\n\tIFT_PFLOG = 0xf6\n\tIFT_PFSYNC = 0xf7\n\tIFT_PLC = 0xae\n\tIFT_POS = 0xab\n\tIFT_PPPMULTILINKBUNDLE = 0x6c\n\tIFT_PROPBWAP2MP = 0xb8\n\tIFT_PROPCNLS = 0x59\n\tIFT_PROPDOCSWIRELESSDOWNSTREAM = 0xb5\n\tIFT_PROPDOCSWIRELESSMACLAYER = 0xb4\n\tIFT_PROPDOCSWIRELESSUPSTREAM = 0xb6\n\tIFT_PROPMUX = 0x36\n\tIFT_PROPWIRELESSP2P = 0x9d\n\tIFT_PTPSERIAL = 0x16\n\tIFT_PVC = 0xf1\n\tIFT_QLLC = 0x44\n\tIFT_RADIOMAC = 0xbc\n\tIFT_RADSL = 0x5f\n\tIFT_REACHDSL = 0xc0\n\tIFT_RFC1483 = 0x9f\n\tIFT_RS232 = 0x21\n\tIFT_RSRB = 0x4f\n\tIFT_SDLC = 0x11\n\tIFT_SDSL = 0x60\n\tIFT_SHDSL = 0xa9\n\tIFT_SIP = 0x1f\n\tIFT_SLIP = 0x1c\n\tIFT_SMDSDXI = 0x2b\n\tIFT_SMDSICIP = 0x34\n\tIFT_SONET = 0x27\n\tIFT_SONETOVERHEADCHANNEL = 0xb9\n\tIFT_SONETPATH = 0x32\n\tIFT_SONETVT = 0x33\n\tIFT_SRP = 0x97\n\tIFT_SS7SIGLINK = 0x9c\n\tIFT_STACKTOSTACK = 0x6f\n\tIFT_STARLAN = 0xb\n\tIFT_STF = 0xd7\n\tIFT_T1 = 0x12\n\tIFT_TDLC = 0x74\n\tIFT_TERMPAD = 0x5b\n\tIFT_TR008 = 0xb0\n\tIFT_TRANSPHDLC = 0x7b\n\tIFT_TUNNEL = 0x83\n\tIFT_ULTRA = 0x1d\n\tIFT_USB = 0xa0\n\tIFT_V11 = 0x40\n\tIFT_V35 = 0x2d\n\tIFT_V36 = 0x41\n\tIFT_V37 = 0x78\n\tIFT_VDSL = 0x61\n\tIFT_VIRTUALIPADDRESS = 0x70\n\tIFT_VOICEEM = 0x64\n\tIFT_VOICEENCAP = 0x67\n\tIFT_VOICEFXO = 0x65\n\tIFT_VOICEFXS = 0x66\n\tIFT_VOICEOVERATM = 0x98\n\tIFT_VOICEOVERFRAMERELAY = 0x99\n\tIFT_VOICEOVERIP = 0x68\n\tIFT_X213 = 0x5d\n\tIFT_X25 = 0x5\n\tIFT_X25DDN = 0x4\n\tIFT_X25HUNTGROUP = 0x7a\n\tIFT_X25MLP = 0x79\n\tIFT_X25PLE = 0x28\n\tIFT_XETHER = 0x1a\n\tIPPROTO_MAXID = 0x34\n\tIPV6_FAITH = 0x1d\n\tIPV6_MIN_MEMBERSHIPS = 0x1f\n\tIP_FAITH = 0x16\n\tIP_MAX_SOURCE_FILTER = 0x400\n\tIP_MIN_MEMBERSHIPS = 0x1f\n\tMAP_NORESERVE = 0x40\n\tMAP_RENAME = 0x20\n\tNET_RT_MAXID = 0x6\n\tRTF_PRCLONING = 0x10000\n\tRTM_OLDADD = 0x9\n\tRTM_OLDDEL = 0xa\n\tRT_CACHING_CONTEXT = 0x1\n\tRT_NORTREF = 0x2\n\tSIOCADDRT = 0x8040720a\n\tSIOCALIFADDR = 0x8118691b\n\tSIOCDELRT = 0x8040720b\n\tSIOCDLIFADDR = 0x8118691d\n\tSIOCGLIFADDR = 0xc118691c\n\tSIOCGLIFPHYADDR = 0xc118694b\n\tSIOCSLIFPHYADDR = 0x8118694a\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/errors_freebsd_arm.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage unix\n\nconst (\n\tIFT_1822 = 0x2\n\tIFT_A12MPPSWITCH = 0x82\n\tIFT_AAL2 = 0xbb\n\tIFT_AAL5 = 0x31\n\tIFT_ADSL = 0x5e\n\tIFT_AFLANE8023 = 0x3b\n\tIFT_AFLANE8025 = 0x3c\n\tIFT_ARAP = 0x58\n\tIFT_ARCNET = 0x23\n\tIFT_ARCNETPLUS = 0x24\n\tIFT_ASYNC = 0x54\n\tIFT_ATM = 0x25\n\tIFT_ATMDXI = 0x69\n\tIFT_ATMFUNI = 0x6a\n\tIFT_ATMIMA = 0x6b\n\tIFT_ATMLOGICAL = 0x50\n\tIFT_ATMRADIO = 0xbd\n\tIFT_ATMSUBINTERFACE = 0x86\n\tIFT_ATMVCIENDPT = 0xc2\n\tIFT_ATMVIRTUAL = 0x95\n\tIFT_BGPPOLICYACCOUNTING = 0xa2\n\tIFT_BSC = 0x53\n\tIFT_CCTEMUL = 0x3d\n\tIFT_CEPT = 0x13\n\tIFT_CES = 0x85\n\tIFT_CHANNEL = 0x46\n\tIFT_CNR = 0x55\n\tIFT_COFFEE = 0x84\n\tIFT_COMPOSITELINK = 0x9b\n\tIFT_DCN = 0x8d\n\tIFT_DIGITALPOWERLINE = 0x8a\n\tIFT_DIGITALWRAPPEROVERHEADCHANNEL = 0xba\n\tIFT_DLSW = 0x4a\n\tIFT_DOCSCABLEDOWNSTREAM = 0x80\n\tIFT_DOCSCABLEMACLAYER = 0x7f\n\tIFT_DOCSCABLEUPSTREAM = 0x81\n\tIFT_DS0 = 0x51\n\tIFT_DS0BUNDLE = 0x52\n\tIFT_DS1FDL = 0xaa\n\tIFT_DS3 = 0x1e\n\tIFT_DTM = 0x8c\n\tIFT_DVBASILN = 0xac\n\tIFT_DVBASIOUT = 0xad\n\tIFT_DVBRCCDOWNSTREAM = 0x93\n\tIFT_DVBRCCMACLAYER = 0x92\n\tIFT_DVBRCCUPSTREAM = 0x94\n\tIFT_ENC = 0xf4\n\tIFT_EON = 0x19\n\tIFT_EPLRS = 0x57\n\tIFT_ESCON = 0x49\n\tIFT_ETHER = 0x6\n\tIFT_FAST = 0x7d\n\tIFT_FASTETHER = 0x3e\n\tIFT_FASTETHERFX = 0x45\n\tIFT_FDDI = 0xf\n\tIFT_FIBRECHANNEL = 0x38\n\tIFT_FRAMERELAYINTERCONNECT = 0x3a\n\tIFT_FRAMERELAYMPI = 0x5c\n\tIFT_FRDLCIENDPT = 0xc1\n\tIFT_FRELAY = 0x20\n\tIFT_FRELAYDCE = 0x2c\n\tIFT_FRF16MFRBUNDLE = 0xa3\n\tIFT_FRFORWARD = 0x9e\n\tIFT_G703AT2MB = 0x43\n\tIFT_G703AT64K = 0x42\n\tIFT_GIF = 0xf0\n\tIFT_GIGABITETHERNET = 0x75\n\tIFT_GR303IDT = 0xb2\n\tIFT_GR303RDT = 0xb1\n\tIFT_H323GATEKEEPER = 0xa4\n\tIFT_H323PROXY = 0xa5\n\tIFT_HDH1822 = 0x3\n\tIFT_HDLC = 0x76\n\tIFT_HDSL2 = 0xa8\n\tIFT_HIPERLAN2 = 0xb7\n\tIFT_HIPPI = 0x2f\n\tIFT_HIPPIINTERFACE = 0x39\n\tIFT_HOSTPAD = 0x5a\n\tIFT_HSSI = 0x2e\n\tIFT_HY = 0xe\n\tIFT_IBM370PARCHAN = 0x48\n\tIFT_IDSL = 0x9a\n\tIFT_IEEE80211 = 0x47\n\tIFT_IEEE80212 = 0x37\n\tIFT_IEEE8023ADLAG = 0xa1\n\tIFT_IFGSN = 0x91\n\tIFT_IMT = 0xbe\n\tIFT_INTERLEAVE = 0x7c\n\tIFT_IP = 0x7e\n\tIFT_IPFORWARD = 0x8e\n\tIFT_IPOVERATM = 0x72\n\tIFT_IPOVERCDLC = 0x6d\n\tIFT_IPOVERCLAW = 0x6e\n\tIFT_IPSWITCH = 0x4e\n\tIFT_ISDN = 0x3f\n\tIFT_ISDNBASIC = 0x14\n\tIFT_ISDNPRIMARY = 0x15\n\tIFT_ISDNS = 0x4b\n\tIFT_ISDNU = 0x4c\n\tIFT_ISO88022LLC = 0x29\n\tIFT_ISO88023 = 0x7\n\tIFT_ISO88024 = 0x8\n\tIFT_ISO88025 = 0x9\n\tIFT_ISO88025CRFPINT = 0x62\n\tIFT_ISO88025DTR = 0x56\n\tIFT_ISO88025FIBER = 0x73\n\tIFT_ISO88026 = 0xa\n\tIFT_ISUP = 0xb3\n\tIFT_L3IPXVLAN = 0x89\n\tIFT_LAPB = 0x10\n\tIFT_LAPD = 0x4d\n\tIFT_LAPF = 0x77\n\tIFT_LOCALTALK = 0x2a\n\tIFT_LOOP = 0x18\n\tIFT_MEDIAMAILOVERIP = 0x8b\n\tIFT_MFSIGLINK = 0xa7\n\tIFT_MIOX25 = 0x26\n\tIFT_MODEM = 0x30\n\tIFT_MPC = 0x71\n\tIFT_MPLS = 0xa6\n\tIFT_MPLSTUNNEL = 0x96\n\tIFT_MSDSL = 0x8f\n\tIFT_MVL = 0xbf\n\tIFT_MYRINET = 0x63\n\tIFT_NFAS = 0xaf\n\tIFT_NSIP = 0x1b\n\tIFT_OPTICALCHANNEL = 0xc3\n\tIFT_OPTICALTRANSPORT = 0xc4\n\tIFT_OTHER = 0x1\n\tIFT_P10 = 0xc\n\tIFT_P80 = 0xd\n\tIFT_PARA = 0x22\n\tIFT_PFLOG = 0xf6\n\tIFT_PFSYNC = 0xf7\n\tIFT_PLC = 0xae\n\tIFT_POS = 0xab\n\tIFT_PPPMULTILINKBUNDLE = 0x6c\n\tIFT_PROPBWAP2MP = 0xb8\n\tIFT_PROPCNLS = 0x59\n\tIFT_PROPDOCSWIRELESSDOWNSTREAM = 0xb5\n\tIFT_PROPDOCSWIRELESSMACLAYER = 0xb4\n\tIFT_PROPDOCSWIRELESSUPSTREAM = 0xb6\n\tIFT_PROPMUX = 0x36\n\tIFT_PROPWIRELESSP2P = 0x9d\n\tIFT_PTPSERIAL = 0x16\n\tIFT_PVC = 0xf1\n\tIFT_QLLC = 0x44\n\tIFT_RADIOMAC = 0xbc\n\tIFT_RADSL = 0x5f\n\tIFT_REACHDSL = 0xc0\n\tIFT_RFC1483 = 0x9f\n\tIFT_RS232 = 0x21\n\tIFT_RSRB = 0x4f\n\tIFT_SDLC = 0x11\n\tIFT_SDSL = 0x60\n\tIFT_SHDSL = 0xa9\n\tIFT_SIP = 0x1f\n\tIFT_SLIP = 0x1c\n\tIFT_SMDSDXI = 0x2b\n\tIFT_SMDSICIP = 0x34\n\tIFT_SONET = 0x27\n\tIFT_SONETOVERHEADCHANNEL = 0xb9\n\tIFT_SONETPATH = 0x32\n\tIFT_SONETVT = 0x33\n\tIFT_SRP = 0x97\n\tIFT_SS7SIGLINK = 0x9c\n\tIFT_STACKTOSTACK = 0x6f\n\tIFT_STARLAN = 0xb\n\tIFT_STF = 0xd7\n\tIFT_T1 = 0x12\n\tIFT_TDLC = 0x74\n\tIFT_TERMPAD = 0x5b\n\tIFT_TR008 = 0xb0\n\tIFT_TRANSPHDLC = 0x7b\n\tIFT_TUNNEL = 0x83\n\tIFT_ULTRA = 0x1d\n\tIFT_USB = 0xa0\n\tIFT_V11 = 0x40\n\tIFT_V35 = 0x2d\n\tIFT_V36 = 0x41\n\tIFT_V37 = 0x78\n\tIFT_VDSL = 0x61\n\tIFT_VIRTUALIPADDRESS = 0x70\n\tIFT_VOICEEM = 0x64\n\tIFT_VOICEENCAP = 0x67\n\tIFT_VOICEFXO = 0x65\n\tIFT_VOICEFXS = 0x66\n\tIFT_VOICEOVERATM = 0x98\n\tIFT_VOICEOVERFRAMERELAY = 0x99\n\tIFT_VOICEOVERIP = 0x68\n\tIFT_X213 = 0x5d\n\tIFT_X25 = 0x5\n\tIFT_X25DDN = 0x4\n\tIFT_X25HUNTGROUP = 0x7a\n\tIFT_X25MLP = 0x79\n\tIFT_X25PLE = 0x28\n\tIFT_XETHER = 0x1a\n\n\t// missing constants on FreeBSD-11.1-RELEASE, copied from old values in ztypes_freebsd_arm.go\n\tIFF_SMART = 0x20\n\tIFT_FAITH = 0xf2\n\tIFT_IPXIP = 0xf9\n\tIPPROTO_MAXID = 0x34\n\tIPV6_FAITH = 0x1d\n\tIP_FAITH = 0x16\n\tMAP_NORESERVE = 0x40\n\tMAP_RENAME = 0x20\n\tNET_RT_MAXID = 0x6\n\tRTF_PRCLONING = 0x10000\n\tRTM_OLDADD = 0x9\n\tRTM_OLDDEL = 0xa\n\tSIOCADDRT = 0x8030720a\n\tSIOCALIFADDR = 0x8118691b\n\tSIOCDELRT = 0x8030720b\n\tSIOCDLIFADDR = 0x8118691d\n\tSIOCGLIFADDR = 0xc118691c\n\tSIOCGLIFPHYADDR = 0xc118694b\n\tSIOCSLIFPHYADDR = 0x8118694a\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/errors_freebsd_arm64.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Constants that were deprecated or moved to enums in the FreeBSD headers. Keep\n// them here for backwards compatibility.\n\npackage unix\n\nconst (\n\tDLT_HHDLC = 0x79\n\tIPV6_MIN_MEMBERSHIPS = 0x1f\n\tIP_MAX_SOURCE_FILTER = 0x400\n\tIP_MIN_MEMBERSHIPS = 0x1f\n\tRT_CACHING_CONTEXT = 0x1\n\tRT_NORTREF = 0x2\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl.go",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build dragonfly || freebsd || linux || netbsd || openbsd\n// +build dragonfly freebsd linux netbsd openbsd\n\npackage unix\n\nimport \"unsafe\"\n\n// fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux\n// systems by fcntl_linux_32bit.go to be SYS_FCNTL64.\nvar fcntl64Syscall uintptr = SYS_FCNTL\n\nfunc fcntl(fd int, cmd, arg int) (int, error) {\n\tvalptr, _, errno := Syscall(fcntl64Syscall, uintptr(fd), uintptr(cmd), uintptr(arg))\n\tvar err error\n\tif errno != 0 {\n\t\terr = errno\n\t}\n\treturn int(valptr), err\n}\n\n// FcntlInt performs a fcntl syscall on fd with the provided command and argument.\nfunc FcntlInt(fd uintptr, cmd, arg int) (int, error) {\n\treturn fcntl(int(fd), cmd, arg)\n}\n\n// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.\nfunc FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {\n\t_, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))\n\tif errno == 0 {\n\t\treturn nil\n\t}\n\treturn errno\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl_darwin.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage unix\n\nimport \"unsafe\"\n\n// FcntlInt performs a fcntl syscall on fd with the provided command and argument.\nfunc FcntlInt(fd uintptr, cmd, arg int) (int, error) {\n\treturn fcntl(int(fd), cmd, arg)\n}\n\n// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.\nfunc FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {\n\t_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))\n\treturn err\n}\n\n// FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command.\nfunc FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error {\n\t_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore))))\n\treturn err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc)\n// +build linux,386 linux,arm linux,mips linux,mipsle linux,ppc\n\npackage unix\n\nfunc init() {\n\t// On 32-bit Linux systems, the fcntl syscall that matches Go's\n\t// Flock_t type is SYS_FCNTL64, not SYS_FCNTL.\n\tfcntl64Syscall = SYS_FCNTL64\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fdset.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos\n\npackage unix\n\n// Set adds fd to the set fds.\nfunc (fds *FdSet) Set(fd int) {\n\tfds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS))\n}\n\n// Clear removes fd from the set fds.\nfunc (fds *FdSet) Clear(fd int) {\n\tfds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS))\n}\n\n// IsSet returns whether fd is in the set fds.\nfunc (fds *FdSet) IsSet(fd int) bool {\n\treturn fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0\n}\n\n// Zero clears the set fds.\nfunc (fds *FdSet) Zero() {\n\tfor i := range fds.Bits {\n\t\tfds.Bits[i] = 0\n\t}\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fstatfs_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n// +build zos,s390x\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent.\n\nfunc Fstatfs(fd int, stat *Statfs_t) (err error) {\n\tvar stat_v Statvfs_t\n\terr = Fstatvfs(fd, &stat_v)\n\tif err == nil {\n\t\t// populate stat\n\t\tstat.Type = 0\n\t\tstat.Bsize = stat_v.Bsize\n\t\tstat.Blocks = stat_v.Blocks\n\t\tstat.Bfree = stat_v.Bfree\n\t\tstat.Bavail = stat_v.Bavail\n\t\tstat.Files = stat_v.Files\n\t\tstat.Ffree = stat_v.Ffree\n\t\tstat.Fsid = stat_v.Fsid\n\t\tstat.Namelen = stat_v.Namemax\n\t\tstat.Frsize = stat_v.Frsize\n\t\tstat.Flags = stat_v.Flag\n\t\tfor passn := 0; passn < 5; passn++ {\n\t\t\tswitch passn {\n\t\t\tcase 0:\n\t\t\t\terr = tryGetmntent64(stat)\n\t\t\t\tbreak\n\t\t\tcase 1:\n\t\t\t\terr = tryGetmntent128(stat)\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\terr = tryGetmntent256(stat)\n\t\t\t\tbreak\n\t\t\tcase 3:\n\t\t\t\terr = tryGetmntent512(stat)\n\t\t\t\tbreak\n\t\t\tcase 4:\n\t\t\t\terr = tryGetmntent1024(stat)\n\t\t\t\tbreak\n\t\t\tdefault:\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t//proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred)\n\t\t\tif err == nil || err != nil && err != ERANGE {\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent64(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [64]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent128(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [128]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent256(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [256]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent512(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [512]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent1024(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [1024]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gccgo && !aix\n// +build gccgo,!aix\n\npackage unix\n\nimport \"syscall\"\n\n// We can't use the gc-syntax .s files for gccgo. On the plus side\n// much of the functionality can be written directly in Go.\n\nfunc realSyscallNoError(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r uintptr)\n\nfunc realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, errno uintptr)\n\nfunc SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {\n\tsyscall.Entersyscall()\n\tr := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0\n}\n\nfunc Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {\n\tr := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\treturn r, 0\n}\n\nfunc RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tr, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)\n\treturn r, 0, syscall.Errno(errno)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo_c.c",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// +build gccgo\n// +build !aix\n\n#include \n#include \n#include \n\n#define _STRINGIFY2_(x) #x\n#define _STRINGIFY_(x) _STRINGIFY2_(x)\n#define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)\n\n// Call syscall from C code because the gccgo support for calling from\n// Go to C does not support varargs functions.\n\nstruct ret {\n\tuintptr_t r;\n\tuintptr_t err;\n};\n\nstruct ret gccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n __asm__(GOSYM_PREFIX GOPKGPATH \".realSyscall\");\n\nstruct ret\ngccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n{\n\tstruct ret r;\n\n\terrno = 0;\n\tr.r = syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n\tr.err = errno;\n\treturn r;\n}\n\nuintptr_t gccgoRealSyscallNoError(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n __asm__(GOSYM_PREFIX GOPKGPATH \".realSyscallNoError\");\n\nuintptr_t\ngccgoRealSyscallNoError(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n{\n\treturn syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gccgo && linux && amd64\n// +build gccgo,linux,amd64\n\npackage unix\n\nimport \"syscall\"\n\n//extern gettimeofday\nfunc realGettimeofday(*Timeval, *byte) int32\n\nfunc gettimeofday(tv *Timeval) (err syscall.Errno) {\n\tr := realGettimeofday(tv, nil)\n\tif r < 0 {\n\t\treturn syscall.GetErrno()\n\t}\n\treturn 0\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ifreq_linux.go",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux\n// +build linux\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// Helpers for dealing with ifreq since it contains a union and thus requires a\n// lot of unsafe.Pointer casts to use properly.\n\n// An Ifreq is a type-safe wrapper around the raw ifreq struct. An Ifreq\n// contains an interface name and a union of arbitrary data which can be\n// accessed using the Ifreq's methods. To create an Ifreq, use the NewIfreq\n// function.\n//\n// Use the Name method to access the stored interface name. The union data\n// fields can be get and set using the following methods:\n// - Uint16/SetUint16: flags\n// - Uint32/SetUint32: ifindex, metric, mtu\ntype Ifreq struct{ raw ifreq }\n\n// NewIfreq creates an Ifreq with the input network interface name after\n// validating the name does not exceed IFNAMSIZ-1 (trailing NULL required)\n// bytes.\nfunc NewIfreq(name string) (*Ifreq, error) {\n\t// Leave room for terminating NULL byte.\n\tif len(name) >= IFNAMSIZ {\n\t\treturn nil, EINVAL\n\t}\n\n\tvar ifr ifreq\n\tcopy(ifr.Ifrn[:], name)\n\n\treturn &Ifreq{raw: ifr}, nil\n}\n\n// TODO(mdlayher): get/set methods for hardware address sockaddr, char array, etc.\n\n// Name returns the interface name associated with the Ifreq.\nfunc (ifr *Ifreq) Name() string {\n\treturn ByteSliceToString(ifr.raw.Ifrn[:])\n}\n\n// According to netdevice(7), only AF_INET addresses are returned for numerous\n// sockaddr ioctls. For convenience, we expose these as Inet4Addr since the Port\n// field and other data is always empty.\n\n// Inet4Addr returns the Ifreq union data from an embedded sockaddr as a C\n// in_addr/Go []byte (4-byte IPv4 address) value. If the sockaddr family is not\n// AF_INET, an error is returned.\nfunc (ifr *Ifreq) Inet4Addr() ([]byte, error) {\n\traw := *(*RawSockaddrInet4)(unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]))\n\tif raw.Family != AF_INET {\n\t\t// Cannot safely interpret raw.Addr bytes as an IPv4 address.\n\t\treturn nil, EINVAL\n\t}\n\n\treturn raw.Addr[:], nil\n}\n\n// SetInet4Addr sets a C in_addr/Go []byte (4-byte IPv4 address) value in an\n// embedded sockaddr within the Ifreq's union data. v must be 4 bytes in length\n// or an error will be returned.\nfunc (ifr *Ifreq) SetInet4Addr(v []byte) error {\n\tif len(v) != 4 {\n\t\treturn EINVAL\n\t}\n\n\tvar addr [4]byte\n\tcopy(addr[:], v)\n\n\tifr.clear()\n\t*(*RawSockaddrInet4)(\n\t\tunsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]),\n\t) = RawSockaddrInet4{\n\t\t// Always set IP family as ioctls would require it anyway.\n\t\tFamily: AF_INET,\n\t\tAddr: addr,\n\t}\n\n\treturn nil\n}\n\n// Uint16 returns the Ifreq union data as a C short/Go uint16 value.\nfunc (ifr *Ifreq) Uint16() uint16 {\n\treturn *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0]))\n}\n\n// SetUint16 sets a C short/Go uint16 value as the Ifreq's union data.\nfunc (ifr *Ifreq) SetUint16(v uint16) {\n\tifr.clear()\n\t*(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0])) = v\n}\n\n// Uint32 returns the Ifreq union data as a C int/Go uint32 value.\nfunc (ifr *Ifreq) Uint32() uint32 {\n\treturn *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0]))\n}\n\n// SetUint32 sets a C int/Go uint32 value as the Ifreq's union data.\nfunc (ifr *Ifreq) SetUint32(v uint32) {\n\tifr.clear()\n\t*(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0])) = v\n}\n\n// clear zeroes the ifreq's union field to prevent trailing garbage data from\n// being sent to the kernel if an ifreq is reused.\nfunc (ifr *Ifreq) clear() {\n\tfor i := range ifr.raw.Ifru {\n\t\tifr.raw.Ifru[i] = 0\n\t}\n}\n\n// TODO(mdlayher): export as IfreqData? For now we can provide helpers such as\n// IoctlGetEthtoolDrvinfo which use these APIs under the hood.\n\n// An ifreqData is an Ifreq which carries pointer data. To produce an ifreqData,\n// use the Ifreq.withData method.\ntype ifreqData struct {\n\tname [IFNAMSIZ]byte\n\t// A type separate from ifreq is required in order to comply with the\n\t// unsafe.Pointer rules since the \"pointer-ness\" of data would not be\n\t// preserved if it were cast into the byte array of a raw ifreq.\n\tdata unsafe.Pointer\n\t// Pad to the same size as ifreq.\n\t_ [len(ifreq{}.Ifru) - SizeofPtr]byte\n}\n\n// withData produces an ifreqData with the pointer p set for ioctls which require\n// arbitrary pointer data.\nfunc (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {\n\treturn ifreqData{\n\t\tname: ifr.raw.Ifrn,\n\t\tdata: p,\n\t}\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris\n// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris\n\npackage unix\n\nimport (\n\t\"runtime\"\n\t\"unsafe\"\n)\n\n// ioctl itself should not be exposed directly, but additional get/set\n// functions for specific types are permissible.\n\n// IoctlSetInt performs an ioctl operation which sets an integer value\n// on fd, using the specified request number.\nfunc IoctlSetInt(fd int, req uint, value int) error {\n\treturn ioctl(fd, req, uintptr(value))\n}\n\n// IoctlSetPointerInt performs an ioctl operation which sets an\n// integer value on fd, using the specified request number. The ioctl\n// argument is called with a pointer to the integer value, rather than\n// passing the integer value directly.\nfunc IoctlSetPointerInt(fd int, req uint, value int) error {\n\tv := int32(value)\n\treturn ioctl(fd, req, uintptr(unsafe.Pointer(&v)))\n}\n\n// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.\n//\n// To change fd's window size, the req argument should be TIOCSWINSZ.\nfunc IoctlSetWinsize(fd int, req uint, value *Winsize) error {\n\t// TODO: if we get the chance, remove the req parameter and\n\t// hardcode TIOCSWINSZ.\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(value)))\n\truntime.KeepAlive(value)\n\treturn err\n}\n\n// IoctlSetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value will usually be TCSETA or TIOCSETA.\nfunc IoctlSetTermios(fd int, req uint, value *Termios) error {\n\t// TODO: if we get the chance, remove the req parameter.\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(value)))\n\truntime.KeepAlive(value)\n\treturn err\n}\n\n// IoctlGetInt performs an ioctl operation which gets an integer value\n// from fd, using the specified request number.\n//\n// A few ioctl requests use the return value as an output parameter;\n// for those, IoctlRetInt should be used instead of this function.\nfunc IoctlGetInt(fd int, req uint) (int, error) {\n\tvar value int\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))\n\treturn value, err\n}\n\nfunc IoctlGetWinsize(fd int, req uint) (*Winsize, error) {\n\tvar value Winsize\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))\n\treturn &value, err\n}\n\nfunc IoctlGetTermios(fd int, req uint) (*Termios, error) {\n\tvar value Termios\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))\n\treturn &value, err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_linux.go",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// IoctlRetInt performs an ioctl operation specified by req on a device\n// associated with opened file descriptor fd, and returns a non-negative\n// integer that is returned by the ioctl syscall.\nfunc IoctlRetInt(fd int, req uint) (int, error) {\n\tret, _, err := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), 0)\n\tif err != 0 {\n\t\treturn 0, err\n\t}\n\treturn int(ret), nil\n}\n\nfunc IoctlGetUint32(fd int, req uint) (uint32, error) {\n\tvar value uint32\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn value, err\n}\n\nfunc IoctlGetRTCTime(fd int) (*RTCTime, error) {\n\tvar value RTCTime\n\terr := ioctlPtr(fd, RTC_RD_TIME, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlSetRTCTime(fd int, value *RTCTime) error {\n\treturn ioctlPtr(fd, RTC_SET_TIME, unsafe.Pointer(value))\n}\n\nfunc IoctlGetRTCWkAlrm(fd int) (*RTCWkAlrm, error) {\n\tvar value RTCWkAlrm\n\terr := ioctlPtr(fd, RTC_WKALM_RD, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlSetRTCWkAlrm(fd int, value *RTCWkAlrm) error {\n\treturn ioctlPtr(fd, RTC_WKALM_SET, unsafe.Pointer(value))\n}\n\n// IoctlGetEthtoolDrvinfo fetches ethtool driver information for the network\n// device specified by ifname.\nfunc IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {\n\tifr, err := NewIfreq(ifname)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvalue := EthtoolDrvinfo{Cmd: ETHTOOL_GDRVINFO}\n\tifrd := ifr.withData(unsafe.Pointer(&value))\n\n\terr = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)\n\treturn &value, err\n}\n\n// IoctlGetWatchdogInfo fetches information about a watchdog device from the\n// Linux watchdog API. For more information, see:\n// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.\nfunc IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {\n\tvar value WatchdogInfo\n\terr := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\n// IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For\n// more information, see:\n// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.\nfunc IoctlWatchdogKeepalive(fd int) error {\n\t// arg is ignored and not a pointer, so ioctl is fine instead of ioctlPtr.\n\treturn ioctl(fd, WDIOC_KEEPALIVE, 0)\n}\n\n// IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the\n// range of data conveyed in value to the file associated with the file\n// descriptor destFd. See the ioctl_ficlonerange(2) man page for details.\nfunc IoctlFileCloneRange(destFd int, value *FileCloneRange) error {\n\treturn ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))\n}\n\n// IoctlFileClone performs an FICLONE ioctl operation to clone the entire file\n// associated with the file description srcFd to the file associated with the\n// file descriptor destFd. See the ioctl_ficlone(2) man page for details.\nfunc IoctlFileClone(destFd, srcFd int) error {\n\treturn ioctl(destFd, FICLONE, uintptr(srcFd))\n}\n\ntype FileDedupeRange struct {\n\tSrc_offset uint64\n\tSrc_length uint64\n\tReserved1 uint16\n\tReserved2 uint32\n\tInfo []FileDedupeRangeInfo\n}\n\ntype FileDedupeRangeInfo struct {\n\tDest_fd int64\n\tDest_offset uint64\n\tBytes_deduped uint64\n\tStatus int32\n\tReserved uint32\n}\n\n// IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the\n// range of data conveyed in value from the file associated with the file\n// descriptor srcFd to the value.Info destinations. See the\n// ioctl_fideduperange(2) man page for details.\nfunc IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {\n\tbuf := make([]byte, SizeofRawFileDedupeRange+\n\t\tlen(value.Info)*SizeofRawFileDedupeRangeInfo)\n\trawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))\n\trawrange.Src_offset = value.Src_offset\n\trawrange.Src_length = value.Src_length\n\trawrange.Dest_count = uint16(len(value.Info))\n\trawrange.Reserved1 = value.Reserved1\n\trawrange.Reserved2 = value.Reserved2\n\n\tfor i := range value.Info {\n\t\trawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(\n\t\t\tuintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +\n\t\t\t\tuintptr(i*SizeofRawFileDedupeRangeInfo)))\n\t\trawinfo.Dest_fd = value.Info[i].Dest_fd\n\t\trawinfo.Dest_offset = value.Info[i].Dest_offset\n\t\trawinfo.Bytes_deduped = value.Info[i].Bytes_deduped\n\t\trawinfo.Status = value.Info[i].Status\n\t\trawinfo.Reserved = value.Info[i].Reserved\n\t}\n\n\terr := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))\n\n\t// Output\n\tfor i := range value.Info {\n\t\trawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(\n\t\t\tuintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +\n\t\t\t\tuintptr(i*SizeofRawFileDedupeRangeInfo)))\n\t\tvalue.Info[i].Dest_fd = rawinfo.Dest_fd\n\t\tvalue.Info[i].Dest_offset = rawinfo.Dest_offset\n\t\tvalue.Info[i].Bytes_deduped = rawinfo.Bytes_deduped\n\t\tvalue.Info[i].Status = rawinfo.Status\n\t\tvalue.Info[i].Reserved = rawinfo.Reserved\n\t}\n\n\treturn err\n}\n\nfunc IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {\n\treturn ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))\n}\n\nfunc IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {\n\tvar value HIDRawDevInfo\n\terr := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlHIDGetRawName(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWNAME_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\nfunc IoctlHIDGetRawPhys(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWPHYS_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\nfunc IoctlHIDGetRawUniq(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWUNIQ_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\n// IoctlIfreq performs an ioctl using an Ifreq structure for input and/or\n// output. See the netdevice(7) man page for details.\nfunc IoctlIfreq(fd int, req uint, value *Ifreq) error {\n\t// It is possible we will add more fields to *Ifreq itself later to prevent\n\t// misuse, so pass the raw *ifreq directly.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(&value.raw))\n}\n\n// TODO(mdlayher): export if and when IfreqData is exported.\n\n// ioctlIfreqData performs an ioctl using an ifreqData structure for input\n// and/or output. See the netdevice(7) man page for details.\nfunc ioctlIfreqData(fd int, req uint, value *ifreqData) error {\n\t// The memory layout of IfreqData (type-safe) and ifreq (not type-safe) are\n\t// identical so pass *IfreqData directly.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlKCMClone attaches a new file descriptor to a multiplexor by cloning an\n// existing KCM socket, returning a structure containing the file descriptor of\n// the new socket.\nfunc IoctlKCMClone(fd int) (*KCMClone, error) {\n\tvar info KCMClone\n\tif err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn &info, nil\n}\n\n// IoctlKCMAttach attaches a TCP socket and associated BPF program file\n// descriptor to a multiplexor.\nfunc IoctlKCMAttach(fd int, info KCMAttach) error {\n\treturn ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))\n}\n\n// IoctlKCMUnattach unattaches a TCP socket file descriptor from a multiplexor.\nfunc IoctlKCMUnattach(fd int, info KCMUnattach) error {\n\treturn ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n// +build zos,s390x\n\npackage unix\n\nimport (\n\t\"runtime\"\n\t\"unsafe\"\n)\n\n// ioctl itself should not be exposed directly, but additional get/set\n// functions for specific types are permissible.\n\n// IoctlSetInt performs an ioctl operation which sets an integer value\n// on fd, using the specified request number.\nfunc IoctlSetInt(fd int, req uint, value int) error {\n\treturn ioctl(fd, req, uintptr(value))\n}\n\n// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.\n//\n// To change fd's window size, the req argument should be TIOCSWINSZ.\nfunc IoctlSetWinsize(fd int, req uint, value *Winsize) error {\n\t// TODO: if we get the chance, remove the req parameter and\n\t// hardcode TIOCSWINSZ.\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(value)))\n\truntime.KeepAlive(value)\n\treturn err\n}\n\n// IoctlSetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value is expected to be TCSETS, TCSETSW, or TCSETSF\nfunc IoctlSetTermios(fd int, req uint, value *Termios) error {\n\tif (req != TCSETS) && (req != TCSETSW) && (req != TCSETSF) {\n\t\treturn ENOSYS\n\t}\n\terr := Tcsetattr(fd, int(req), value)\n\truntime.KeepAlive(value)\n\treturn err\n}\n\n// IoctlGetInt performs an ioctl operation which gets an integer value\n// from fd, using the specified request number.\n//\n// A few ioctl requests use the return value as an output parameter;\n// for those, IoctlRetInt should be used instead of this function.\nfunc IoctlGetInt(fd int, req uint) (int, error) {\n\tvar value int\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))\n\treturn value, err\n}\n\nfunc IoctlGetWinsize(fd int, req uint) (*Winsize, error) {\n\tvar value Winsize\n\terr := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))\n\treturn &value, err\n}\n\n// IoctlGetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value is expected to be TCGETS\nfunc IoctlGetTermios(fd int, req uint) (*Termios, error) {\n\tvar value Termios\n\tif req != TCGETS {\n\t\treturn &value, ENOSYS\n\t}\n\terr := Tcgetattr(fd, &value)\n\treturn &value, err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/mkall.sh",
"content": "#!/usr/bin/env bash\n# Copyright 2009 The Go Authors. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n# This script runs or (given -n) prints suggested commands to generate files for\n# the Architecture/OS specified by the GOARCH and GOOS environment variables.\n# See README.md for more information about how the build system works.\n\nGOOSARCH=\"${GOOS}_${GOARCH}\"\n\n# defaults\nmksyscall=\"go run mksyscall.go\"\nmkerrors=\"./mkerrors.sh\"\nzerrors=\"zerrors_$GOOSARCH.go\"\nmksysctl=\"\"\nzsysctl=\"zsysctl_$GOOSARCH.go\"\nmksysnum=\nmktypes=\nmkasm=\nrun=\"sh\"\ncmd=\"\"\n\ncase \"$1\" in\n-syscalls)\n\tfor i in zsyscall*go\n\tdo\n\t\t# Run the command line that appears in the first line\n\t\t# of the generated file to regenerate it.\n\t\tsed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i\n\t\trm _$i\n\tdone\n\texit 0\n\t;;\n-n)\n\trun=\"cat\"\n\tcmd=\"echo\"\n\tshift\nesac\n\ncase \"$#\" in\n0)\n\t;;\n*)\n\techo 'usage: mkall.sh [-n]' 1>&2\n\texit 2\nesac\n\nif [[ \"$GOOS\" = \"linux\" ]]; then\n\t# Use the Docker-based build system\n\t# Files generated through docker (use $cmd so you can Ctl-C the build or run)\n\t$cmd docker build --tag generate:$GOOS $GOOS\n\t$cmd docker run --interactive --tty --volume $(cd -- \"$(dirname -- \"$0\")/..\" && /bin/pwd):/build generate:$GOOS\n\texit\nfi\n\nGOOSARCH_in=syscall_$GOOSARCH.go\ncase \"$GOOSARCH\" in\n_* | *_ | _)\n\techo 'undefined $GOOS_$GOARCH:' \"$GOOSARCH\" 1>&2\n\texit 1\n\t;;\naix_ppc)\n\tmkerrors=\"$mkerrors -maix32\"\n\tmksyscall=\"go run mksyscall_aix_ppc.go -aix\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\naix_ppc64)\n\tmkerrors=\"$mkerrors -maix64\"\n\tmksyscall=\"go run mksyscall_aix_ppc64.go -aix\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\ndarwin_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\tmkasm=\"go run mkasm_darwin.go\"\n\t;;\ndarwin_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\tmkasm=\"go run mkasm_darwin.go\"\n\t;;\ndragonfly_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -dragonfly\"\n\tmksysnum=\"go run mksysnum.go 'https://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_386)\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32\"\n\tmksysnum=\"go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\"go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_arm)\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -arm\"\n\tmksysnum=\"go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nfreebsd_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\"go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nnetbsd_386)\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32 -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nnetbsd_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nnetbsd_arm)\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -netbsd -arm\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nnetbsd_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_386)\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32 -openbsd\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmksysnum=\"go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmksysnum=\"go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_arm)\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -openbsd -arm\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmksysnum=\"go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmksysnum=\"go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_mips64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmksysnum=\"go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nsolaris_amd64)\n\tmksyscall=\"go run mksyscall_solaris.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nillumos_amd64)\n mksyscall=\"go run mksyscall_solaris.go\"\n\tmkerrors=\n\tmksysnum=\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\n*)\n\techo 'unrecognized $GOOS_$GOARCH: ' \"$GOOSARCH\" 1>&2\n\texit 1\n\t;;\nesac\n\n(\n\tif [ -n \"$mkerrors\" ]; then echo \"$mkerrors |gofmt >$zerrors\"; fi\n\tcase \"$GOOS\" in\n\t*)\n\t\tsyscall_goos=\"syscall_$GOOS.go\"\n\t\tcase \"$GOOS\" in\n\t\tdarwin | dragonfly | freebsd | netbsd | openbsd)\n\t\t\tsyscall_goos=\"syscall_bsd.go $syscall_goos\"\n\t\t\t;;\n\t\tesac\n\t\tif [ -n \"$mksyscall\" ]; then\n\t\t\tif [ \"$GOOSARCH\" == \"aix_ppc64\" ]; then\n\t\t\t\t# aix/ppc64 script generates files instead of writing to stdin.\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in && gofmt -w zsyscall_$GOOSARCH.go && gofmt -w zsyscall_\"$GOOSARCH\"_gccgo.go && gofmt -w zsyscall_\"$GOOSARCH\"_gc.go \" ;\n\t\t\telif [ \"$GOOS\" == \"darwin\" ]; then\n\t\t\t # 1.12 and later, syscalls via libSystem\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH,go1.12 $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go\";\n\t\t\t\t# 1.13 and later, syscalls via libSystem (including syscallPtr)\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH,go1.13 syscall_darwin.1_13.go |gofmt >zsyscall_$GOOSARCH.1_13.go\";\n\t\t\telif [ \"$GOOS\" == \"illumos\" ]; then\n\t\t\t # illumos code generation requires a --illumos switch\n\t\t\t echo \"$mksyscall -illumos -tags illumos,$GOARCH syscall_illumos.go |gofmt > zsyscall_illumos_$GOARCH.go\";\n\t\t\t # illumos implies solaris, so solaris code generation is also required\n\t\t\t\techo \"$mksyscall -tags solaris,$GOARCH syscall_solaris.go syscall_solaris_$GOARCH.go |gofmt >zsyscall_solaris_$GOARCH.go\";\n\t\t\telse\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go\";\n\t\t\tfi\n\t\tfi\n\tesac\n\tif [ -n \"$mksysctl\" ]; then echo \"$mksysctl |gofmt >$zsysctl\"; fi\n\tif [ -n \"$mksysnum\" ]; then echo \"$mksysnum |gofmt >zsysnum_$GOOSARCH.go\"; fi\n\tif [ -n \"$mktypes\" ]; then echo \"$mktypes types_$GOOS.go | go run mkpost.go > ztypes_$GOOSARCH.go\"; fi\n\tif [ -n \"$mkasm\" ]; then echo \"$mkasm $GOARCH\"; fi\n) | $run\n"
},
{
"path": "vendor/golang.org/x/sys/unix/mkerrors.sh",
"content": "#!/usr/bin/env bash\n# Copyright 2009 The Go Authors. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n# Generate Go code listing errors and other #defined constant\n# values (ENAMETOOLONG etc.), by asking the preprocessor\n# about the definitions.\n\nunset LANG\nexport LC_ALL=C\nexport LC_CTYPE=C\n\nif test -z \"$GOARCH\" -o -z \"$GOOS\"; then\n\techo 1>&2 \"GOARCH or GOOS not defined in environment\"\n\texit 1\nfi\n\n# Check that we are using the new build system if we should\nif [[ \"$GOOS\" = \"linux\" ]] && [[ \"$GOLANG_SYS_BUILD\" != \"docker\" ]]; then\n\techo 1>&2 \"In the Docker based build system, mkerrors should not be called directly.\"\n\techo 1>&2 \"See README.md\"\n\texit 1\nfi\n\nif [[ \"$GOOS\" = \"aix\" ]]; then\n\tCC=${CC:-gcc}\nelse\n\tCC=${CC:-cc}\nfi\n\nif [[ \"$GOOS\" = \"solaris\" ]]; then\n\t# Assumes GNU versions of utilities in PATH.\n\texport PATH=/usr/gnu/bin:$PATH\nfi\n\nuname=$(uname)\n\nincludes_AIX='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define AF_LOCAL AF_UNIX\n'\n\nincludes_Darwin='\n#define _DARWIN_C_SOURCE\n#define KERNEL 1\n#define _DARWIN_USE_64_BIT_INODE\n#define __APPLE_USE_RFC_3542\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// for backwards compatibility because moved TIOCREMOTE to Kernel.framework after MacOSX12.0.sdk.\n#define TIOCREMOTE 0x80047469\n'\n\nincludes_DragonFly='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n'\n\nincludes_FreeBSD='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if __FreeBSD__ >= 10\n#define IFT_CARP\t0xf8\t// IFT_CARP is deprecated in FreeBSD 10\n#undef SIOCAIFADDR\n#define SIOCAIFADDR\t_IOW(105, 26, struct oifaliasreq)\t// ifaliasreq contains if_data\n#undef SIOCSIFPHYADDR\n#define SIOCSIFPHYADDR\t_IOW(105, 70, struct oifaliasreq)\t// ifaliasreq contains if_data\n#endif\n'\n\nincludes_Linux='\n#define _LARGEFILE_SOURCE\n#define _LARGEFILE64_SOURCE\n#ifndef __LP64__\n#define _FILE_OFFSET_BITS 64\n#endif\n#define _GNU_SOURCE\n\n//