Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 nflog.pb.go // Code generated by protoc-gen-gogo. DO NOT EDIT. // source: nflog.proto package nflogpb import ( fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Receiver struct { // Configured name of the receiver group. GroupName string `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"` // Name of the integration of the receiver. Integration string `protobuf:"bytes,2,opt,name=integration,proto3" json:"integration,omitempty"` // Index of the receiver with respect to the integration. // Every integration in a group may have 0..N configurations. Idx uint32 `protobuf:"varint,3,opt,name=idx,proto3" json:"idx,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m Receiver) Reset() { m = Receiver{} } func (m Receiver) String() string { return proto.CompactTextString(m) } func (Receiver) ProtoMessage() {} func (Receiver) Descriptor() ([]byte, []int) { return fileDescriptor_c2d9785ad9c3e602, []int{0} } func (m Receiver) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m Receiver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Receiver.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m Receiver) XXX_Merge(src proto.Message) { xxx_messageInfo_Receiver.Merge(m, src) } func (m Receiver) XXX_Size() int { return m.Size() } func (m Receiver) XXX_DiscardUnknown() { xxx_messageInfo_Receiver.DiscardUnknown(m) } var xxx_messageInfo_Receiver proto.InternalMessageInfo // Entry holds information about a successful notification // sent to a receiver. type Entry struct { // The key identifying the dispatching group. GroupKey []byte `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` // The receiver that was notified. Receiver Receiver `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"` // Hash over the state of the group at notification time. // Deprecated in favor of FiringAlerts field, but kept for compatibility. GroupHash []byte `protobuf:"bytes,3,opt,name=group_hash,json=groupHash,proto3" json:"group_hash,omitempty"` // Whether the notification was about a resolved alert. // Deprecated in favor of ResolvedAlerts field, but kept for compatibility. Resolved bool `protobuf:"varint,4,opt,name=resolved,proto3" json:"resolved,omitempty"` // Timestamp of the succeeding notification. Timestamp time.Time `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"` // FiringAlerts list of hashes of firing alerts at the last notification time. FiringAlerts []uint64 `protobuf:"varint,6,rep,packed,name=firing_alerts,json=firingAlerts,proto3" json:"firing_alerts,omitempty"` // ResolvedAlerts list of hashes of resolved alerts at the last notification time. ResolvedAlerts []uint64 `protobuf:"varint,7,rep,packed,name=resolved_alerts,json=resolvedAlerts,proto3" json:"resolved_alerts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m Entry) Reset() { m = Entry{} } func (m Entry) String() string { return proto.CompactTextString(m) } func (Entry) ProtoMessage() {} func (Entry) Descriptor() ([]byte, []int) { return fileDescriptor_c2d9785ad9c3e602, []int{1} } func (m Entry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Entry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m Entry) XXX_Merge(src proto.Message) { xxx_messageInfo_Entry.Merge(m, src) } func (m Entry) XXX_Size() int { return m.Size() } func (m Entry) XXX_DiscardUnknown() { xxx_messageInfo_Entry.DiscardUnknown(m) } var xxx_messageInfo_Entry proto.InternalMessageInfo // MeshEntry is a wrapper message to communicate a notify log // entry through a mesh network. type MeshEntry struct { // The original raw notify log entry. Entry Entry `protobuf:"bytes,1,opt,name=entry,proto3" json:"entry,omitempty"` // A timestamp indicating when the mesh peer should evict // the log entry from its state. ExpiresAt time.Time `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,proto3,stdtime" json:"expires_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m MeshEntry) Reset() { m = MeshEntry{} } func (m MeshEntry) String() string { return proto.CompactTextString(m) } func (MeshEntry) ProtoMessage() {} func (MeshEntry) Descriptor() ([]byte, []int) { return fileDescriptor_c2d9785ad9c3e602, []int{2} } func (m MeshEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m MeshEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MeshEntry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m MeshEntry) XXX_Merge(src proto.Message) { xxx_messageInfo_MeshEntry.Merge(m, src) } func (m MeshEntry) XXX_Size() int { return m.Size() } func (m MeshEntry) XXX_DiscardUnknown() { xxx_messageInfo_MeshEntry.DiscardUnknown(m) } var xxx_messageInfo_MeshEntry proto.InternalMessageInfo func init() { proto.RegisterType((Receiver)(nil), "nflogpb.Receiver") proto.RegisterType((Entry)(nil), "nflogpb.Entry") proto.RegisterType((MeshEntry)(nil), "nflogpb.MeshEntry") } func init() { proto.RegisterFile("nflog.proto", fileDescriptor_c2d9785ad9c3e602) } var fileDescriptor_c2d9785ad9c3e602 = []byte{ // 385 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0xcf, 0x6e, 0xd3, 0x40, 0x10, 0xc6, 0xbb, 0x4d, 0xd3, 0xda, 0xe3, 0xb4, 0x94, 0x15, 0x07, 0xcb, 0x08, 0xc7, 0x0a, 0x48, 0xf8, 0x82, 0x23, 0x95, 0x27, 0x68, 0x10, 0x12, 0x12, 0x82, 0xc3, 0x8a, 0x2b, 0xb2, 0x36, 0x74, 0xb2, 0x5e, 0x61, 0x7b, 0xad, 0xf5, 0x36, 0x6a, 0xde, 0x82, 0x47, 0xe0, 0x71, 0x72, 0xe4, 0x09, 0xf8, 0x93, 0x27, 0x41, 0xde, 0xb5, 0x1d, 0x8e, 0xdc, 0x66, 0x7f, 0xf3, 0xcd, 0xcc, 0xb7, 0x1f, 0x04, 0xf5, 0xa6, 0x54, 0x22, 0x6b, 0xb4, 0x32, 0x8a, 0x5e, 0xd8, 0x47, 0xb3, 0x8e, 0xe6, 0x42, 0x29, 0x51, 0xe2, 0xd2, 0xe2, 0xf5, 0xfd, 0x66, 0x69, 0x64, 0x85, 0xad, 0xe1, 0x55, 0xe3, 0x94, 0xd1, 0x13, 0xa1, 0x84, 0xb2, 0xe5, 0xb2, 0xab, 0x1c, 0x5d, 0x7c, 0x06, 0x8f, 0xe1, 0x17, 0x94, 0x5b, 0xd4, 0xf4, 0x19, 0x80, 0xd0, 0xea, 0xbe, 0xc9, 0x6b, 0x5e, 0x61, 0x48, 0x12, 0x92, 0xfa, 0xcc, 0xb7, 0xe4, 0x23, 0xaf, 0x90, 0x26, 0x10, 0xc8, 0xda, 0xa0, 0xd0, 0xdc, 0x48, 0x55, 0x87, 0xa7, 0xb6, 0xff, 0x2f, 0xa2, 0xd7, 0x30, 0x91, 0x77, 0x0f, 0xe1, 0x24, 0x21, 0xe9, 0x25, 0xeb, 0xca, 0xc5, 0xf7, 0x53, 0x98, 0xbe, 0xad, 0x8d, 0xde, 0xd1, 0xa7, 0xe0, 0x56, 0xe5, 0x5f, 0x71, 0x67, 0x77, 0xcf, 0x98, 0x67, 0xc1, 0x7b, 0xdc, 0xd1, 0x57, 0xe0, 0xe9, 0xde, 0x85, 0xdd, 0x1b, 0xdc, 0x3c, 0xce, 0xfa, 0x8f, 0x65, 0x83, 0x3d, 0x36, 0x4a, 0x8e, 0x46, 0x0b, 0xde, 0x16, 0xf6, 0xdc, 0xac, 0x37, 0xfa, 0x8e, 0xb7, 0x05, 0x8d, 0xba, 0x6d, 0xad, 0x2a, 0xb7, 0x78, 0x17, 0x9e, 0x25, 0x24, 0xf5, 0xd8, 0xf8, 0xa6, 0x2b, 0xf0, 0xc7, 0x60, 0xc2, 0xa9, 0x3d, 0x15, 0x65, 0x2e, 0xba, 0x6c, 0x88, 0x2e, 0xfb, 0x34, 0x28, 0x56, 0xde, 0xfe, 0xe7, 0xfc, 0xe4, 0xdb, 0xaf, 0x39, 0x61, 0xc7, 0x31, 0xfa, 0x1c, 0x2e, 0x37, 0x52, 0xcb, 0x5a, 0xe4, 0xbc, 0x44, 0x6d, 0xda, 0xf0, 0x3c, 0x99, 0xa4, 0x67, 0x6c, 0xe6, 0xe0, 0xad, 0x65, 0xf4, 0x25, 0x3c, 0x1a, 0x8e, 0x0e, 0xb2, 0x0b, 0x2b, 0xbb, 0x1a, 0xb0, 0x13, 0x2e, 0xb6, 0xe0, 0x7f, 0xc0, 0xb6, 0x70, 0x29, 0xbd, 0x80, 0x29, 0x76, 0x85, 0x4d, 0x28, 0xb8, 0xb9, 0x1a, 0x53, 0xb0, 0x6d, 0xe6, 0x9a, 0xf4, 0x0d, 0x00, 0x3e, 0x34, 0x52, 0x63, 0x9b, 0x73, 0xd3, 0x07, 0xf6, 0x9f, 0xbf, 0xe8, 0xe7, 0x6e, 0xcd, 0xea, 0x7a, 0xff, 0x27, 0x3e, 0xd9, 0x1f, 0x62, 0xf2, 0xe3, 0x10, 0x93, 0xdf, 0x87, 0x98, 0xac, 0xcf, 0xed, 0xe8, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x49, 0xcd, 0xa7, 0x1e, 0x61, 0x02, 0x00, 0x00, } func (m Receiver) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m Receiver) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m Receiver) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Idx != 0 { i = encodeVarintNflog(dAtA, i, uint64(m.Idx)) i-- dAtA[i] = 0x18 } if len(m.Integration) > 0 { i -= len(m.Integration) copy(dAtA[i:], m.Integration) i = encodeVarintNflog(dAtA, i, uint64(len(m.Integration))) i-- dAtA[i] = 0x12 } if len(m.GroupName) > 0 { i -= len(m.GroupName) copy(dAtA[i:], m.GroupName) i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupName))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m Entry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m Entry) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m Entry) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ResolvedAlerts) > 0 { dAtA2 := make([]byte, len(m.ResolvedAlerts)10) var j1 int for _, num := range m.ResolvedAlerts { for num >= 1<<7 { dAtA2[j1] = uint8(uint64(num)&0x7f \| 0x80) num >>= 7 j1++ } dAtA2[j1] = uint8(num) j1++ } i -= j1 copy(dAtA[i:], dAtA2[:j1]) i = encodeVarintNflog(dAtA, i, uint64(j1)) i-- dAtA[i] = 0x3a } if len(m.FiringAlerts) > 0 { dAtA4 := make([]byte, len(m.FiringAlerts)10) var j3 int for _, num := range m.FiringAlerts { for num >= 1<<7 { dAtA4[j3] = uint8(uint64(num)&0x7f \| 0x80) num >>= 7 j3++ } dAtA4[j3] = uint8(num) j3++ } i -= j3 copy(dAtA[i:], dAtA4[:j3]) i = encodeVarintNflog(dAtA, i, uint64(j3)) i-- dAtA[i] = 0x32 } n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):]) if err5 != nil { return 0, err5 } i -= n5 i = encodeVarintNflog(dAtA, i, uint64(n5)) i-- dAtA[i] = 0x2a if m.Resolved { i-- if m.Resolved { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if len(m.GroupHash) > 0 { i -= len(m.GroupHash) copy(dAtA[i:], m.GroupHash) i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupHash))) i-- dAtA[i] = 0x1a } if m.Receiver != nil { { size, err := m.Receiver.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNflog(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.GroupKey) > 0 { i -= len(m.GroupKey) copy(dAtA[i:], m.GroupKey) i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupKey))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m MeshEntry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m MeshEntry) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m MeshEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExpiresAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt):]) if err7 != nil { return 0, err7 } i -= n7 i = encodeVarintNflog(dAtA, i, uint64(n7)) i-- dAtA[i] = 0x12 if m.Entry != nil { { size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNflog(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintNflog(dAtA []byte, offset int, v uint64) int { offset -= sovNflog(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f \| 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m Receiver) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.GroupName) if l > 0 { n += 1 + l + sovNflog(uint64(l)) } l = len(m.Integration) if l > 0 { n += 1 + l + sovNflog(uint64(l)) } if m.Idx != 0 { n += 1 + sovNflog(uint64(m.Idx)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m Entry) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.GroupKey) if l > 0 { n += 1 + l + sovNflog(uint64(l)) } if m.Receiver != nil { l = m.Receiver.Size() n += 1 + l + sovNflog(uint64(l)) } l = len(m.GroupHash) if l > 0 { n += 1 + l + sovNflog(uint64(l)) } if m.Resolved { n += 2 } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp) n += 1 + l + sovNflog(uint64(l)) if len(m.FiringAlerts) > 0 { l = 0 for _, e := range m.FiringAlerts { l += sovNflog(uint64(e)) } n += 1 + sovNflog(uint64(l)) + l } if len(m.ResolvedAlerts) > 0 { l = 0 for _, e := range m.ResolvedAlerts { l += sovNflog(uint64(e)) } n += 1 + sovNflog(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m MeshEntry) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Entry != nil { l = m.Entry.Size() n += 1 + l + sovNflog(uint64(l)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt) n += 1 + l + sovNflog(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovNflog(x uint64) (n int) { return (math_bits.Len64(x\|1) + 6) / 7 } func sozNflog(x uint64) (n int) { return sovNflog(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m Receiver) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire \|= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Receiver: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Receiver: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen \|= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } m.GroupName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen \|= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } m.Integration = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType) } m.Idx = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Idx \|= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipNflog(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) \|\| (iNdEx+skippy) < 0 { return ErrInvalidLengthNflog } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m Entry) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire \|= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Entry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen \|= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } m.GroupKey = append(m.GroupKey[:0], dAtA[iNdEx:postIndex]...) if m.GroupKey == nil { m.GroupKey = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen \|= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } if m.Receiver == nil { m.Receiver = &Receiver{} } if err := m.Receiver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GroupHash", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen \|= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } m.GroupHash = append(m.GroupHash[:0], dAtA[iNdEx:postIndex]...) if m.GroupHash == nil { m.GroupHash = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Resolved", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v \|= int(b&0x7F) << shift if b < 0x80 { break } } m.Resolved = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen \|= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v \|= uint64(b&0x7F) << shift if b < 0x80 { break } } m.FiringAlerts = append(m.FiringAlerts, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen \|= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.FiringAlerts) == 0 { m.FiringAlerts = make([]uint64, 0, elementCount) } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v \|= uint64(b&0x7F) << shift if b < 0x80 { break } } m.FiringAlerts = append(m.FiringAlerts, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field FiringAlerts", wireType) } case 7: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v \|= uint64(b&0x7F) << shift if b < 0x80 { break } } m.ResolvedAlerts = append(m.ResolvedAlerts, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen \|= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.ResolvedAlerts) == 0 { m.ResolvedAlerts = make([]uint64, 0, elementCount) } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v \|= uint64(b&0x7F) << shift if b < 0x80 { break } } m.ResolvedAlerts = append(m.ResolvedAlerts, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field ResolvedAlerts", wireType) } default: iNdEx = preIndex skippy, err := skipNflog(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) \|\| (iNdEx+skippy) < 0 { return ErrInvalidLengthNflog } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m MeshEntry) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire \|= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: MeshEntry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MeshEntry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen \|= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } if m.Entry == nil { m.Entry = &Entry{} } if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNflog } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen \|= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNflog } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNflog } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExpiresAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNflog(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) \|\| (iNdEx+skippy) < 0 { return ErrInvalidLengthNflog } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipNflog(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNflog } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire \|= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNflog } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNflog } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length \|= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthNflog } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupNflog } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthNflog } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthNflog = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowNflog = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupNflog = fmt.Errorf("proto: unexpected end of group") )	29.8 KB	2025-05-25 12:27
📄 nflog.proto syntax = "proto3"; package nflogpb; import "google/protobuf/timestamp.proto"; import "gogoproto/gogo.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.goproto_getters_all) = false; message Receiver { // Configured name of the receiver group. string group_name = 1; // Name of the integration of the receiver. string integration = 2; // Index of the receiver with respect to the integration. // Every integration in a group may have 0..N configurations. uint32 idx = 3; } // Entry holds information about a successful notification // sent to a receiver. message Entry { // The key identifying the dispatching group. bytes group_key = 1; // The receiver that was notified. Receiver receiver = 2; // Hash over the state of the group at notification time. // Deprecated in favor of FiringAlerts field, but kept for compatibility. bytes group_hash = 3; // Whether the notification was about a resolved alert. // Deprecated in favor of ResolvedAlerts field, but kept for compatibility. bool resolved = 4; // Timestamp of the succeeding notification. google.protobuf.Timestamp timestamp = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // FiringAlerts list of hashes of firing alerts at the last notification time. repeated uint64 firing_alerts = 6; // ResolvedAlerts list of hashes of resolved alerts at the last notification time. repeated uint64 resolved_alerts = 7; } // MeshEntry is a wrapper message to communicate a notify log // entry through a mesh network. message MeshEntry { // The original raw notify log entry. Entry entry = 1; // A timestamp indicating when the mesh peer should evict // the log entry from its state. google.protobuf.Timestamp expires_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; }	1.86 KB	2025-05-25 12:27
📄 set.go // Copyright 2017 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package nflogpb // IsFiringSubset returns whether the given subset is a subset of the alerts // that were firing at the time of the last notification. func (m Entry) IsFiringSubset(subset map[uint64]struct{}) bool { set := map[uint64]struct{}{} for i := range m.FiringAlerts { set[m.FiringAlerts[i]] = struct{}{} } return isSubset(set, subset) } // IsResolvedSubset returns whether the given subset is a subset of the alerts // that were resolved at the time of the last notification. func (m Entry) IsResolvedSubset(subset map[uint64]struct{}) bool { set := map[uint64]struct{}{} for i := range m.ResolvedAlerts { set[m.ResolvedAlerts[i]] = struct{}{} } return isSubset(set, subset) } func isSubset(set, subset map[uint64]struct{}) bool { for k := range subset { _, exists := set[k] if !exists { return false } } return true }	1.41 KB	2025-05-25 12:27
📄 set_test.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package nflogpb import ( "testing" ) func TestIsFiringSubset(t testing.T) { e := &Entry{ FiringAlerts: []uint64{1, 2, 3}, } tests := []struct { subset map[uint64]struct{} expected bool }{ {newSubset(), true}, // empty subset {newSubset(1), true}, {newSubset(2), true}, {newSubset(3), true}, {newSubset(1, 2), true}, {newSubset(1, 2), true}, {newSubset(1, 2, 3), true}, {newSubset(4), false}, {newSubset(1, 5), false}, {newSubset(1, 2, 3, 6), false}, } for _, test := range tests { if result := e.IsFiringSubset(test.subset); result != test.expected { t.Errorf("Expected %t, got %t for subset %v", test.expected, result, elements(test.subset)) } } } func TestIsResolvedSubset(t testing.T) { e := &Entry{ ResolvedAlerts: []uint64{1, 2, 3}, } tests := []struct { subset map[uint64]struct{} expected bool }{ {newSubset(), true}, // empty subset {newSubset(1), true}, {newSubset(2), true}, {newSubset(3), true}, {newSubset(1, 2), true}, {newSubset(1, 2), true}, {newSubset(1, 2, 3), true}, {newSubset(4), false}, {newSubset(1, 5), false}, {newSubset(1, 2, 3, 6), false}, } for _, test := range tests { if result := e.IsResolvedSubset(test.subset); result != test.expected { t.Errorf("Expected %t, got %t for subset %v", test.expected, result, elements(test.subset)) } } } func newSubset(elements ...uint64) map[uint64]struct{} { subset := make(map[uint64]struct{}) for _, el := range elements { subset[el] = struct{}{} } return subset } func elements(m map[uint64]struct{}) []uint64 { els := make([]uint64, 0, len(m)) for k := range m { els = append(els, k) } return els }	2.21 KB	2025-05-25 12:27

Terminal