potyarkin/frostfs-api-go
1
0
Fork 0
forked from TrueCloudLab/frostfs-api-go
Code Pull requests Activity

[#134] v2/acl: Regenerate proto files

Browse source 
Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-09-04 10:50:09 +03:00 committed by Stanislav Bogatyrev
parent de505ddee9
commit 09cc2a5037
2 changed files with 237 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
v2/acl/grpc/types.go
View file

@ -4,6 +4,13 @@ import (
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc" refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
) )
// SetVersion sets version of EACL rules in table.
func (m *EACLTable) SetVersion(v *refs.Version) {
if m != nil {
m.Version = v
}
}
// SetContainerId sets container identifier of the eACL table. // SetContainerId sets container identifier of the eACL table.
func (m *EACLTable) SetContainerId(v *refs.ContainerID) { func (m *EACLTable) SetContainerId(v *refs.ContainerID) {
if m != nil { if m != nil {
@ -33,56 +40,56 @@ func (m *EACLRecord) SetAction(v Action) {
} }
// SetFilters sets filter list of the eACL record. // SetFilters sets filter list of the eACL record.
func (m *EACLRecord) SetFilters(v []*EACLRecord_FilterInfo) { func (m *EACLRecord) SetFilters(v []*EACLRecord_Filter) {
if m != nil { if m != nil {
m.Filters = v m.Filters = v
} }
} }
// SetTargets sets target list of the eACL record. // SetTargets sets target list of the eACL record.
func (m *EACLRecord) SetTargets(v []*EACLRecord_TargetInfo) { func (m *EACLRecord) SetTargets(v []*EACLRecord_Target) {
if m != nil { if m != nil {
m.Targets = v m.Targets = v
} }
} }
// SetHeader sets header type of the eACL filter. // SetHeader sets header type of the eACL filter.
func (m *EACLRecord_FilterInfo) SetHeader(v HeaderType) { func (m *EACLRecord_Filter) SetHeader(v HeaderType) {
if m != nil { if m != nil {
m.Header = v m.HeaderType = v
} }
} }
// SetMatchType sets match type of the eACL filter. // SetMatchType sets match type of the eACL filter.
func (m *EACLRecord_FilterInfo) SetMatchType(v MatchType) { func (m *EACLRecord_Filter) SetMatchType(v MatchType) {
if m != nil { if m != nil {
m.MatchType = v m.MatchType = v
} }
} }
// SetHeaderName sets header name of the eACL filter. // SetHeaderName sets header name of the eACL filter.
func (m *EACLRecord_FilterInfo) SetHeaderName(v string) { func (m *EACLRecord_Filter) SetHeaderName(v string) {
if m != nil { if m != nil {
m.HeaderName = v m.HeaderName = v
} }
} }
// SetHeaderVal sets header value of the eACL filter. // SetHeaderVal sets header value of the eACL filter.
func (m *EACLRecord_FilterInfo) SetHeaderVal(v string) { func (m *EACLRecord_Filter) SetHeaderVal(v string) {
if m != nil { if m != nil {
m.HeaderVal = v m.HeaderVal = v
} }
} }
// SetTarget sets target group of the eACL target. // SetRole sets target group of the eACL target.
func (m *EACLRecord_TargetInfo) SetTarget(v Target) { func (m *EACLRecord_Target) SetRole(v Role) {
if m != nil { if m != nil {
m.Target = v m.Role = v
} }
} }
// SetKeyList sets key list of the eACL target. // SetKeyList sets key list of the eACL target.
func (m *EACLRecord_TargetInfo) SetKeyList(v [][]byte) { func (m *EACLRecord_Target) SetKeyList(v [][]byte) {
if m != nil { if m != nil {
m.KeyList = v m.KeyList = v
} }

363
v2/acl/grpc/types.pb.go
View file

@ -23,40 +23,40 @@ var _ = math.Inf
// proto package needs to be updated. // proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// Target of the access control rule in access control list. // Target role of the access control rule in access control list.
type Target int32 type Role int32
const ( const (
// Unspecified target, default value. // Unspecified role, default value.
Target_TARGET_UNSPECIFIED Target = 0 Role_ROLE_UNSPECIFIED Role = 0
// User target rule is applied if sender is the owner of the container. // User target rule is applied if sender is the owner of the container.
Target_USER Target = 1 Role_USER Role = 1
// System target rule is applied if sender is the storage node within the // System target rule is applied if sender is the storage node within the
// container or inner ring node. // container or inner ring node.
Target_SYSTEM Target = 2 Role_SYSTEM Role = 2
// Others target rule is applied if sender is not user or system target. // Others target rule is applied if sender is not user or system target.
Target_OTHERS Target = 3 Role_OTHERS Role = 3
) )
var Target_name = map[int32]string{ var Role_name = map[int32]string{
0: "TARGET_UNSPECIFIED", 0: "ROLE_UNSPECIFIED",
1: "USER", 1: "USER",
2: "SYSTEM", 2: "SYSTEM",
3: "OTHERS", 3: "OTHERS",
} }
var Target_value = map[string]int32{ var Role_value = map[string]int32{
"TARGET_UNSPECIFIED": 0, "ROLE_UNSPECIFIED": 0,
"USER": 1, "USER": 1,
"SYSTEM": 2, "SYSTEM": 2,
"OTHERS": 3, "OTHERS": 3,
} }
func (x Target) String() string { func (x Role) String() string {
return proto.EnumName(Target_name, int32(x)) return proto.EnumName(Role_name, int32(x))
} }
func (Target) EnumDescriptor() ([]byte, []int) { func (Role) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{0} return fileDescriptor_8233b6696fb3e24f, []int{0}
} }
@ -215,9 +215,9 @@ type EACLRecord struct {
// Action carries ACL target action. // Action carries ACL target action.
Action Action `protobuf:"varint,2,opt,name=action,json=Action,proto3,enum=neo.fs.v2.acl.Action" json:"action,omitempty"` Action Action `protobuf:"varint,2,opt,name=action,json=Action,proto3,enum=neo.fs.v2.acl.Action" json:"action,omitempty"`
// filters carries set of filters. // filters carries set of filters.
Filters []*EACLRecord_FilterInfo `protobuf:"bytes,3,rep,name=filters,json=Filters,proto3" json:"filters,omitempty"` Filters []*EACLRecord_Filter `protobuf:"bytes,3,rep,name=filters,json=Filters,proto3" json:"filters,omitempty"`
// targets carries information about extended ACL target list. // targets carries information about extended ACL target list.
Targets []*EACLRecord_TargetInfo `protobuf:"bytes,4,rep,name=targets,json=Targets,proto3" json:"targets,omitempty"` Targets []*EACLRecord_Target `protobuf:"bytes,4,rep,name=targets,json=Targets,proto3" json:"targets,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -270,24 +270,24 @@ func (m *EACLRecord) GetAction() Action {
return Action_ACTION_UNSPECIFIED return Action_ACTION_UNSPECIFIED
} }
func (m *EACLRecord) GetFilters() []*EACLRecord_FilterInfo { func (m *EACLRecord) GetFilters() []*EACLRecord_Filter {
if m != nil { if m != nil {
return m.Filters return m.Filters
} }
return nil return nil
} }
func (m *EACLRecord) GetTargets() []*EACLRecord_TargetInfo { func (m *EACLRecord) GetTargets() []*EACLRecord_Target {
if m != nil { if m != nil {
return m.Targets return m.Targets
} }
return nil return nil
} }
// FilterInfo groups information about filter. // Filter definition
type EACLRecord_FilterInfo struct { type EACLRecord_Filter struct {
// Header carries type of header. // Header carries type of header.
Header HeaderType `protobuf:"varint,1,opt,name=header,json=HeaderType,proto3,enum=neo.fs.v2.acl.HeaderType" json:"header,omitempty"` HeaderType HeaderType `protobuf:"varint,1,opt,name=header_type,json=HeaderType,proto3,enum=neo.fs.v2.acl.HeaderType" json:"header_type,omitempty"`
// MatchType carries type of match. // MatchType carries type of match.
MatchType MatchType `protobuf:"varint,2,opt,name=match_type,json=MatchType,proto3,enum=neo.fs.v2.acl.MatchType" json:"match_type,omitempty"` MatchType MatchType `protobuf:"varint,2,opt,name=match_type,json=MatchType,proto3,enum=neo.fs.v2.acl.MatchType" json:"match_type,omitempty"`
// header_name carries name of filtering header. // header_name carries name of filtering header.
@ -299,18 +299,18 @@ type EACLRecord_FilterInfo struct {
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
} }
func (m *EACLRecord_FilterInfo) Reset() { *m = EACLRecord_FilterInfo{} } func (m *EACLRecord_Filter) Reset() { *m = EACLRecord_Filter{} }
func (m *EACLRecord_FilterInfo) String() string { return proto.CompactTextString(m) } func (m *EACLRecord_Filter) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_FilterInfo) ProtoMessage() {} func (*EACLRecord_Filter) ProtoMessage() {}
func (*EACLRecord_FilterInfo) Descriptor() ([]byte, []int) { func (*EACLRecord_Filter) Descriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{0, 0} return fileDescriptor_8233b6696fb3e24f, []int{0, 0}
} }
func (m *EACLRecord_FilterInfo) XXX_Unmarshal(b []byte) error { func (m *EACLRecord_Filter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *EACLRecord_FilterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *EACLRecord_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic { if deterministic {
return xxx_messageInfo_EACLRecord_FilterInfo.Marshal(b, m, deterministic) return xxx_messageInfo_EACLRecord_Filter.Marshal(b, m, deterministic)
} else { } else {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
@ -320,50 +320,50 @@ func (m *EACLRecord_FilterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byt
return b[:n], nil return b[:n], nil
} }
} }
func (m *EACLRecord_FilterInfo) XXX_Merge(src proto.Message) { func (m *EACLRecord_Filter) XXX_Merge(src proto.Message) {
xxx_messageInfo_EACLRecord_FilterInfo.Merge(m, src) xxx_messageInfo_EACLRecord_Filter.Merge(m, src)
} }
func (m *EACLRecord_FilterInfo) XXX_Size() int { func (m *EACLRecord_Filter) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *EACLRecord_FilterInfo) XXX_DiscardUnknown() { func (m *EACLRecord_Filter) XXX_DiscardUnknown() {
xxx_messageInfo_EACLRecord_FilterInfo.DiscardUnknown(m) xxx_messageInfo_EACLRecord_Filter.DiscardUnknown(m)
} }
var xxx_messageInfo_EACLRecord_FilterInfo proto.InternalMessageInfo var xxx_messageInfo_EACLRecord_Filter proto.InternalMessageInfo
func (m *EACLRecord_FilterInfo) GetHeader() HeaderType { func (m *EACLRecord_Filter) GetHeaderType() HeaderType {
if m != nil { if m != nil {
return m.Header return m.HeaderType
} }
return HeaderType_HEADER_UNSPECIFIED return HeaderType_HEADER_UNSPECIFIED
} }
func (m *EACLRecord_FilterInfo) GetMatchType() MatchType { func (m *EACLRecord_Filter) GetMatchType() MatchType {
if m != nil { if m != nil {
return m.MatchType return m.MatchType
} }
return MatchType_MATCH_TYPE_UNSPECIFIED return MatchType_MATCH_TYPE_UNSPECIFIED
} }
func (m *EACLRecord_FilterInfo) GetHeaderName() string { func (m *EACLRecord_Filter) GetHeaderName() string {
if m != nil { if m != nil {
return m.HeaderName return m.HeaderName
} }
return "" return ""
} }
func (m *EACLRecord_FilterInfo) GetHeaderVal() string { func (m *EACLRecord_Filter) GetHeaderVal() string {
if m != nil { if m != nil {
return m.HeaderVal return m.HeaderVal
} }
return "" return ""
} }
// TargetInfo groups information about extended ACL target. // Information about extended ACL target.
type EACLRecord_TargetInfo struct { type EACLRecord_Target struct {
// target carries target of ACL rule. // target carries target of ACL rule.
Target Target `protobuf:"varint,1,opt,name=target,json=Role,proto3,enum=neo.fs.v2.acl.Target" json:"target,omitempty"` Role Role `protobuf:"varint,1,opt,name=role,json=Role,proto3,enum=neo.fs.v2.acl.Role" json:"role,omitempty"`
// key_list carries public keys of ACL target. // key_list carries public keys of ACL target.
KeyList [][]byte `protobuf:"bytes,2,rep,name=key_list,json=Keys,proto3" json:"key_list,omitempty"` KeyList [][]byte `protobuf:"bytes,2,rep,name=key_list,json=Keys,proto3" json:"key_list,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -371,18 +371,18 @@ type EACLRecord_TargetInfo struct {
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
} }
func (m *EACLRecord_TargetInfo) Reset() { *m = EACLRecord_TargetInfo{} } func (m *EACLRecord_Target) Reset() { *m = EACLRecord_Target{} }
func (m *EACLRecord_TargetInfo) String() string { return proto.CompactTextString(m) } func (m *EACLRecord_Target) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_TargetInfo) ProtoMessage() {} func (*EACLRecord_Target) ProtoMessage() {}
func (*EACLRecord_TargetInfo) Descriptor() ([]byte, []int) { func (*EACLRecord_Target) Descriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{0, 1} return fileDescriptor_8233b6696fb3e24f, []int{0, 1}
} }
func (m *EACLRecord_TargetInfo) XXX_Unmarshal(b []byte) error { func (m *EACLRecord_Target) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *EACLRecord_TargetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *EACLRecord_Target) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic { if deterministic {
return xxx_messageInfo_EACLRecord_TargetInfo.Marshal(b, m, deterministic) return xxx_messageInfo_EACLRecord_Target.Marshal(b, m, deterministic)
} else { } else {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
@ -392,26 +392,26 @@ func (m *EACLRecord_TargetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byt
return b[:n], nil return b[:n], nil
} }
} }
func (m *EACLRecord_TargetInfo) XXX_Merge(src proto.Message) { func (m *EACLRecord_Target) XXX_Merge(src proto.Message) {
xxx_messageInfo_EACLRecord_TargetInfo.Merge(m, src) xxx_messageInfo_EACLRecord_Target.Merge(m, src)
} }
func (m *EACLRecord_TargetInfo) XXX_Size() int { func (m *EACLRecord_Target) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *EACLRecord_TargetInfo) XXX_DiscardUnknown() { func (m *EACLRecord_Target) XXX_DiscardUnknown() {
xxx_messageInfo_EACLRecord_TargetInfo.DiscardUnknown(m) xxx_messageInfo_EACLRecord_Target.DiscardUnknown(m)
} }
var xxx_messageInfo_EACLRecord_TargetInfo proto.InternalMessageInfo var xxx_messageInfo_EACLRecord_Target proto.InternalMessageInfo
func (m *EACLRecord_TargetInfo) GetTarget() Target { func (m *EACLRecord_Target) GetRole() Role {
if m != nil { if m != nil {
return m.Target return m.Role
} }
return Target_TARGET_UNSPECIFIED return Role_ROLE_UNSPECIFIED
} }
func (m *EACLRecord_TargetInfo) GetKeyList() [][]byte { func (m *EACLRecord_Target) GetKeyList() [][]byte {
if m != nil { if m != nil {
return m.KeyList return m.KeyList
} }
@ -420,11 +420,14 @@ func (m *EACLRecord_TargetInfo) GetKeyList() [][]byte {
// EACLRecord carries the information about extended ACL rules. // EACLRecord carries the information about extended ACL rules.
type EACLTable struct { type EACLTable struct {
// eACL format version.
// Effectively the version of API library used to create eACL Table
Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// Carries identifier of the container that should use given // Carries identifier of the container that should use given
// access control rules. // access control rules.
ContainerId *grpc.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=ContainerID,proto3" json:"container_id,omitempty"` ContainerId *grpc.ContainerID `protobuf:"bytes,2,opt,name=container_id,json=ContainerID,proto3" json:"container_id,omitempty"`
// Records carries list of extended ACL rule records. // Records carries list of extended ACL rule records.
Records []*EACLRecord `protobuf:"bytes,2,rep,name=records,json=Records,proto3" json:"records,omitempty"` Records []*EACLRecord `protobuf:"bytes,3,rep,name=records,json=Records,proto3" json:"records,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -463,6 +466,13 @@ func (m *EACLTable) XXX_DiscardUnknown() {
var xxx_messageInfo_EACLTable proto.InternalMessageInfo var xxx_messageInfo_EACLTable proto.InternalMessageInfo
func (m *EACLTable) GetVersion() *grpc.Version {
if m != nil {
return m.Version
}
return nil
}
func (m *EACLTable) GetContainerId() *grpc.ContainerID { func (m *EACLTable) GetContainerId() *grpc.ContainerID {
if m != nil { if m != nil {
return m.ContainerId return m.ContainerId
@ -670,14 +680,14 @@ func (m *BearerToken_Body_TokenLifetime) GetIat() uint64 {
} }
func init() { func init() {
proto.RegisterEnum("neo.fs.v2.acl.Target", Target_name, Target_value) proto.RegisterEnum("neo.fs.v2.acl.Role", Role_name, Role_value)
proto.RegisterEnum("neo.fs.v2.acl.MatchType", MatchType_name, MatchType_value) proto.RegisterEnum("neo.fs.v2.acl.MatchType", MatchType_name, MatchType_value)
proto.RegisterEnum("neo.fs.v2.acl.Operation", Operation_name, Operation_value) proto.RegisterEnum("neo.fs.v2.acl.Operation", Operation_name, Operation_value)
proto.RegisterEnum("neo.fs.v2.acl.Action", Action_name, Action_value) proto.RegisterEnum("neo.fs.v2.acl.Action", Action_name, Action_value)
proto.RegisterEnum("neo.fs.v2.acl.HeaderType", HeaderType_name, HeaderType_value) proto.RegisterEnum("neo.fs.v2.acl.HeaderType", HeaderType_name, HeaderType_value)
proto.RegisterType((*EACLRecord)(nil), "neo.fs.v2.acl.EACLRecord") proto.RegisterType((*EACLRecord)(nil), "neo.fs.v2.acl.EACLRecord")
proto.RegisterType((*EACLRecord_FilterInfo)(nil), "neo.fs.v2.acl.EACLRecord.FilterInfo") proto.RegisterType((*EACLRecord_Filter)(nil), "neo.fs.v2.acl.EACLRecord.Filter")
proto.RegisterType((*EACLRecord_TargetInfo)(nil), "neo.fs.v2.acl.EACLRecord.TargetInfo") proto.RegisterType((*EACLRecord_Target)(nil), "neo.fs.v2.acl.EACLRecord.Target")
proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable") proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable")
proto.RegisterType((*BearerToken)(nil), "neo.fs.v2.acl.BearerToken") proto.RegisterType((*BearerToken)(nil), "neo.fs.v2.acl.BearerToken")
proto.RegisterType((*BearerToken_Body)(nil), "neo.fs.v2.acl.BearerToken.Body") proto.RegisterType((*BearerToken_Body)(nil), "neo.fs.v2.acl.BearerToken.Body")
@ -687,61 +697,62 @@ func init() {
func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) } func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) }
var fileDescriptor_8233b6696fb3e24f = []byte{ var fileDescriptor_8233b6696fb3e24f = []byte{
// 862 bytes of a gzipped FileDescriptorProto // 869 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xdd, 0x6e, 0xe2, 0x46, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xdd, 0x6e, 0xe2, 0x46,
0x18, 0x5d, 0x63, 0x87, 0x9f, 0x8f, 0x6c, 0x65, 0x8d, 0xba, 0x2c, 0xa1, 0x52, 0x1a, 0x45, 0xbd, 0x14, 0x5e, 0xff, 0x04, 0xc3, 0x21, 0x5b, 0x59, 0xd3, 0x6e, 0x16, 0xa8, 0x94, 0xa2, 0xdc, 0x34,
0x88, 0xa8, 0x30, 0x2a, 0xd1, 0x76, 0x2f, 0xaa, 0xae, 0x64, 0x60, 0x02, 0xb4, 0x04, 0x93, 0xf1, 0x42, 0xc2, 0x68, 0x89, 0xda, 0x95, 0xb6, 0xea, 0x4a, 0x06, 0x26, 0x81, 0x96, 0x60, 0x76, 0x6c,
0xb0, 0x55, 0x7a, 0x83, 0x06, 0x33, 0x10, 0x6b, 0x1d, 0x1b, 0xd9, 0x0e, 0x5b, 0x7a, 0x55, 0xa9, 0x52, 0xa5, 0x37, 0x68, 0x30, 0x03, 0xb1, 0xd6, 0xb1, 0x91, 0xed, 0xb0, 0xa5, 0xb7, 0x55, 0xdf,
0xea, 0x3b, 0xf4, 0x19, 0x7a, 0xd9, 0xa7, 0xe8, 0x65, 0x1f, 0xa1, 0x4a, 0x1f, 0xa3, 0x37, 0xd5, 0xa1, 0xcf, 0xd0, 0xdb, 0x7d, 0x89, 0x5e, 0xf6, 0x11, 0xaa, 0xf4, 0xb6, 0x0f, 0x51, 0xcd, 0x18,
0x8c, 0x4d, 0x20, 0xde, 0x95, 0x72, 0xc5, 0xe7, 0xf9, 0xce, 0xf9, 0xce, 0x99, 0x33, 0xa3, 0x01, 0x27, 0xc4, 0x9b, 0xd5, 0xde, 0x30, 0xc7, 0x73, 0xbe, 0xef, 0x9c, 0xef, 0x7c, 0x33, 0xd8, 0xf0,
0x5e, 0xae, 0x5b, 0x4d, 0xe6, 0x78, 0xcd, 0x65, 0xb8, 0x72, 0x9a, 0xf1, 0x66, 0xc5, 0x23, 0x63, 0x7c, 0xdd, 0x6e, 0x51, 0xd7, 0x6f, 0x2d, 0xa3, 0x95, 0xdb, 0x4a, 0x36, 0x2b, 0x16, 0x1b, 0xab,
0x15, 0x06, 0x71, 0x80, 0x9e, 0xfb, 0x3c, 0x30, 0x16, 0x91, 0xb1, 0x6e, 0x19, 0xcc, 0xf1, 0x6a, 0x28, 0x4c, 0x42, 0xf4, 0x34, 0x60, 0xa1, 0xb1, 0x88, 0x8d, 0x75, 0xdb, 0xa0, 0xae, 0x5f, 0xab,
0xd5, 0x75, 0xab, 0x19, 0xf2, 0x45, 0xf4, 0x01, 0xf0, 0xf4, 0x3f, 0x15, 0x00, 0x9b, 0x9d, 0x21, 0xac, 0xdb, 0xad, 0x88, 0x2d, 0xe2, 0x0f, 0x80, 0x47, 0xff, 0x29, 0x00, 0xd8, 0xec, 0x0e, 0x09,
0xe1, 0x4e, 0x10, 0xce, 0xd1, 0xd7, 0x50, 0x0a, 0x56, 0x3c, 0x64, 0xb1, 0x1b, 0xf8, 0x55, 0xe5, 0x73, 0xc3, 0x68, 0x8e, 0xbe, 0x85, 0x52, 0xb8, 0x62, 0x11, 0x4d, 0xbc, 0x30, 0xa8, 0x48, 0x75,
0x44, 0x39, 0xfb, 0xa4, 0x55, 0x35, 0x1e, 0xcd, 0x32, 0xac, 0x6d, 0x9f, 0x94, 0x1e, 0x4a, 0xd4, 0xe9, 0xf8, 0xb3, 0x76, 0xc5, 0x78, 0x50, 0xcb, 0xb0, 0xb2, 0x3c, 0x29, 0xdd, 0x85, 0xa8, 0x09,
0x80, 0x3c, 0x73, 0x24, 0x29, 0x27, 0x49, 0x2f, 0x32, 0x24, 0x53, 0x36, 0x49, 0x3e, 0xf9, 0x45, 0x05, 0xea, 0x0a, 0x92, 0x2c, 0x48, 0xcf, 0x72, 0x24, 0x53, 0x24, 0x49, 0x21, 0x5d, 0xd1, 0x2b,
0x6f, 0xa0, 0xb0, 0x70, 0xbd, 0x98, 0x87, 0x51, 0x55, 0x3d, 0x51, 0xcf, 0xca, 0xad, 0x2f, 0x32, 0xd0, 0x16, 0x9e, 0x9f, 0xb0, 0x28, 0xae, 0x28, 0x75, 0xe5, 0xb8, 0xdc, 0xae, 0xe7, 0xf0, 0xf7,
0xf8, 0x9d, 0x25, 0xe3, 0x42, 0x02, 0x07, 0xfe, 0x22, 0x20, 0x85, 0xa4, 0x8e, 0x04, 0x3f, 0x66, 0x92, 0x8c, 0x53, 0x01, 0x24, 0x5a, 0xba, 0xc6, 0x9c, 0x9b, 0xd0, 0x68, 0xc9, 0x92, 0xb8, 0xa2,
0xe1, 0x92, 0xc7, 0x51, 0x55, 0x7b, 0x8a, 0x4f, 0x25, 0x30, 0xe1, 0x27, 0x75, 0x54, 0xfb, 0x53, 0x7e, 0x8a, 0xeb, 0x08, 0x20, 0xd1, 0xd2, 0x35, 0xae, 0xbd, 0x97, 0xa0, 0x90, 0xd6, 0x41, 0xaf,
0x01, 0xd8, 0xcd, 0x45, 0xaf, 0x20, 0x7f, 0xc3, 0xd9, 0x9c, 0x87, 0xe9, 0x96, 0x8f, 0x32, 0xd3, 0xa0, 0x7c, 0xc5, 0xe8, 0x9c, 0x45, 0x53, 0x6e, 0xc7, 0x76, 0xd6, 0x6a, 0xae, 0x54, 0x5f, 0x20,
0xfa, 0xb2, 0x49, 0x37, 0x2b, 0x4e, 0x60, 0x57, 0xa3, 0xd7, 0x00, 0xb7, 0x2c, 0x76, 0x6e, 0xa6, 0x9c, 0xcd, 0x8a, 0x11, 0xb8, 0x8f, 0xd1, 0x4b, 0x80, 0x6b, 0x9a, 0xb8, 0x57, 0x29, 0x55, 0x7e,
0x22, 0xd0, 0x74, 0xe3, 0xd9, 0xb4, 0x2e, 0x05, 0x40, 0x32, 0x4b, 0x0f, 0x25, 0x3a, 0x82, 0x72, 0xd4, 0xa6, 0x73, 0x0e, 0x10, 0xcc, 0xd2, 0x5d, 0x88, 0xaa, 0x77, 0x4d, 0x03, 0x7a, 0xcd, 0x2a,
0xa2, 0x37, 0xf5, 0xd9, 0x2d, 0xaf, 0xaa, 0x27, 0xca, 0x59, 0x89, 0x68, 0x23, 0x76, 0x2b, 0x5a, 0x4a, 0x5d, 0x3a, 0x2e, 0x11, 0x75, 0x44, 0xaf, 0x79, 0x0a, 0xb6, 0xa9, 0x35, 0xf5, 0x2b, 0xaa,
0x90, 0xb6, 0xd6, 0xcc, 0xab, 0x6a, 0xb2, 0x73, 0xf0, 0x96, 0x79, 0x77, 0xbc, 0x76, 0x05, 0xb0, 0xc8, 0xec, 0x5d, 0x50, 0xff, 0x86, 0xd5, 0x06, 0x50, 0x48, 0x07, 0x40, 0x5f, 0x83, 0x1a, 0x85,
0xdb, 0x0b, 0xfa, 0x12, 0xf2, 0x49, 0x04, 0xa9, 0xe7, 0x6c, 0xe2, 0x09, 0x94, 0x68, 0x24, 0xf0, 0x7e, 0xa6, 0xf6, 0xf3, 0x5c, 0x4b, 0x12, 0xfa, 0x8c, 0xa8, 0xfc, 0x17, 0x1d, 0x40, 0xf1, 0x2d,
0x38, 0xaa, 0x40, 0xf1, 0x1d, 0xdf, 0x4c, 0x3d, 0x37, 0x8a, 0xab, 0xb9, 0x13, 0xf5, 0xec, 0x90, 0xdb, 0x4c, 0x7d, 0x2f, 0x4e, 0x2a, 0x72, 0x5d, 0x39, 0xde, 0x27, 0xea, 0x8f, 0x6c, 0x13, 0x1f,
0x68, 0xdf, 0xf3, 0x4d, 0x74, 0xfa, 0x8b, 0x02, 0x25, 0x11, 0x15, 0x65, 0x33, 0x8f, 0xa3, 0x37, 0xbd, 0x97, 0xa0, 0xc4, 0xfd, 0x71, 0xe8, 0xcc, 0x67, 0xe8, 0x05, 0x68, 0x6b, 0x16, 0xc5, 0xd9,
0x70, 0xe8, 0x04, 0x7e, 0xcc, 0x5c, 0x9f, 0x87, 0x53, 0x77, 0x2e, 0x07, 0x97, 0x5b, 0x9f, 0xed, 0x59, 0x97, 0xdb, 0xcf, 0x77, 0x2a, 0xf2, 0xfb, 0x62, 0x5c, 0xa4, 0x69, 0x92, 0xe1, 0xd0, 0x6b,
0x0d, 0x16, 0x77, 0xc8, 0xe8, 0x6c, 0x31, 0x83, 0x2e, 0x29, 0xef, 0x7d, 0xa0, 0x73, 0x28, 0x84, 0xd8, 0x77, 0xc3, 0x20, 0xa1, 0x5e, 0xc0, 0xa2, 0xa9, 0x37, 0x17, 0xc3, 0x97, 0xdb, 0x5f, 0xe6,
0x32, 0xf3, 0x48, 0x8a, 0x94, 0x3f, 0xc8, 0x71, 0x77, 0x2a, 0xa4, 0x90, 0xfc, 0x46, 0xa7, 0xbf, 0x79, 0xdd, 0x0c, 0x33, 0xe8, 0x91, 0xf2, 0xce, 0x03, 0x3a, 0x01, 0x2d, 0x12, 0x67, 0x93, 0x9d,
0xaa, 0x50, 0x6e, 0x73, 0x16, 0xf2, 0x90, 0x06, 0xef, 0xb8, 0x8f, 0xce, 0x41, 0x9b, 0x05, 0xf3, 0x7c, 0xf5, 0xa3, 0xa7, 0x47, 0xb4, 0x74, 0x8d, 0x8f, 0x7e, 0x53, 0xa0, 0xdc, 0x61, 0x34, 0x62,
0x4d, 0x2a, 0xfe, 0x79, 0x66, 0xc2, 0x1e, 0xd2, 0x68, 0x07, 0xf3, 0x0d, 0x91, 0x60, 0xf4, 0x1a, 0x91, 0x13, 0xbe, 0x65, 0x01, 0x3a, 0x01, 0x75, 0x16, 0xce, 0x37, 0x5b, 0xd1, 0x5f, 0xe5, 0x2a,
0x4a, 0x91, 0xbb, 0xf4, 0x59, 0x7c, 0x17, 0x26, 0x07, 0xf1, 0x58, 0x5b, 0xda, 0xb6, 0xb7, 0x00, 0xec, 0x20, 0x8d, 0x4e, 0x38, 0xdf, 0x10, 0x01, 0x46, 0x2f, 0xa1, 0x14, 0x7b, 0xcb, 0x80, 0x26,
0xb2, 0xc3, 0xd6, 0x7e, 0xcb, 0x81, 0xd6, 0x4e, 0x26, 0x00, 0x67, 0x8e, 0x37, 0x8d, 0x45, 0x12, 0x37, 0x11, 0xdb, 0xca, 0xae, 0xe6, 0x65, 0xdb, 0x19, 0x80, 0xdc, 0x63, 0x6b, 0xbf, 0xcb, 0xa0,
0xa9, 0x78, 0xf5, 0x23, 0xf6, 0x65, 0x52, 0xa4, 0x24, 0xb0, 0x49, 0x68, 0x2d, 0x28, 0x06, 0xef, 0x76, 0xd2, 0x0a, 0xc0, 0xa8, 0xeb, 0x4f, 0x13, 0x6e, 0xde, 0xb6, 0x79, 0xe5, 0x11, 0xf9, 0xc2,
0xd3, 0xc0, 0x12, 0xe5, 0x97, 0x59, 0x65, 0xeb, 0x7d, 0x12, 0x56, 0x41, 0x02, 0x07, 0x73, 0x34, 0x5c, 0x52, 0xe2, 0xd8, 0xd4, 0xe7, 0x36, 0x14, 0xc3, 0x77, 0x0f, 0x0c, 0xfb, 0xc0, 0x68, 0xeb,
0x80, 0xa2, 0xe7, 0x2e, 0x78, 0xec, 0xa6, 0x87, 0x5f, 0x6e, 0x35, 0x9e, 0xd8, 0xa7, 0x21, 0xcb, 0x5d, 0x6a, 0x96, 0x26, 0x80, 0x83, 0x39, 0x1a, 0x40, 0xd1, 0xf7, 0x16, 0x2c, 0xf1, 0xb6, 0xf7,
0x61, 0x4a, 0x22, 0x0f, 0xf4, 0x1a, 0x86, 0xe7, 0x8f, 0x5a, 0x48, 0x07, 0x95, 0xff, 0xb4, 0x92, 0xa4, 0xdc, 0x6e, 0x7e, 0x62, 0x4e, 0x43, 0x84, 0xc3, 0x2d, 0x89, 0xdc, 0xd1, 0x6b, 0x18, 0x9e,
0x3b, 0xd0, 0x88, 0x28, 0xc5, 0x8a, 0x3f, 0x5b, 0x48, 0x73, 0x1a, 0x11, 0xa5, 0x58, 0x71, 0x59, 0x3e, 0x48, 0x21, 0x1d, 0x14, 0xf6, 0xcb, 0x4a, 0x4c, 0xa0, 0x12, 0x1e, 0xf2, 0x9d, 0x60, 0xb6,
0x2c, 0xa5, 0x35, 0x22, 0xca, 0x7a, 0x1b, 0xf2, 0xc9, 0x85, 0x41, 0x15, 0x40, 0xd4, 0x24, 0x3d, 0x10, 0xe2, 0x54, 0xc2, 0x43, 0xbe, 0xe3, 0xd1, 0x44, 0xb4, 0x56, 0x09, 0x0f, 0x1b, 0xaf, 0x21,
0x4c, 0xa7, 0x93, 0x91, 0x3d, 0xc6, 0x9d, 0xc1, 0xc5, 0x00, 0x77, 0xf5, 0x67, 0xa8, 0x08, 0xda, 0xbd, 0x5b, 0x5f, 0x80, 0x4e, 0xac, 0x21, 0x9e, 0x4e, 0x46, 0xf6, 0x18, 0x77, 0x07, 0xa7, 0x03,
0xc4, 0xc6, 0x44, 0x57, 0x10, 0x40, 0xde, 0xbe, 0xb6, 0x29, 0xbe, 0xd4, 0x73, 0xa2, 0xb6, 0x68, 0xdc, 0xd3, 0x9f, 0xa0, 0x22, 0xa8, 0x13, 0x1b, 0x13, 0x5d, 0x42, 0x00, 0x05, 0xfb, 0xd2, 0x76,
0x1f, 0x13, 0x5b, 0x57, 0xeb, 0x16, 0xec, 0x5d, 0xf1, 0x1a, 0x54, 0x2e, 0x4d, 0xda, 0xe9, 0x4f, 0xf0, 0xb9, 0x2e, 0xf3, 0xd8, 0x72, 0xfa, 0x98, 0xd8, 0xba, 0xd2, 0xb0, 0x60, 0xe7, 0x9f, 0x50,
0xe9, 0xf5, 0x18, 0x67, 0x46, 0xe9, 0x70, 0x68, 0x53, 0x32, 0x18, 0xf5, 0xa6, 0xf8, 0x6a, 0x62, 0x83, 0x83, 0x73, 0xd3, 0xe9, 0xf6, 0xa7, 0xce, 0xe5, 0x38, 0x5f, 0x4a, 0x87, 0x7d, 0xdb, 0x21,
0x0e, 0x75, 0x05, 0x7d, 0x0a, 0x7a, 0xba, 0x32, 0xb2, 0x68, 0xba, 0x9a, 0xab, 0xff, 0x0c, 0x7b, 0x83, 0xd1, 0xd9, 0x14, 0xbf, 0x99, 0x98, 0x43, 0x5d, 0xe2, 0x2d, 0xb7, 0x3b, 0x23, 0xcb, 0xd9,
0x2f, 0xcc, 0x11, 0xbc, 0xb0, 0xc6, 0x98, 0x98, 0x74, 0x60, 0x8d, 0x32, 0xf3, 0x0a, 0xa0, 0xf6, 0xee, 0xca, 0x8d, 0x5f, 0x61, 0xe7, 0x0d, 0x54, 0x85, 0x67, 0xd6, 0x18, 0x13, 0xd3, 0x19, 0x58,
0x30, 0xd5, 0x15, 0xe1, 0xb1, 0x8f, 0xcd, 0xae, 0x9e, 0x13, 0x4b, 0xe3, 0x09, 0xd5, 0x55, 0x61, 0xa3, 0x5c, 0x3d, 0x0d, 0x94, 0x33, 0xec, 0xe8, 0x12, 0xd7, 0xd8, 0xc7, 0x66, 0x4f, 0x97, 0xf9,
0xb0, 0x8b, 0x87, 0x98, 0x62, 0x5d, 0x93, 0xc6, 0xb1, 0x49, 0x3a, 0x7d, 0xfd, 0x00, 0x1d, 0x42, 0xd6, 0x78, 0xe2, 0xe8, 0x0a, 0x17, 0xd8, 0xc3, 0x43, 0xec, 0x60, 0x5d, 0x15, 0xc2, 0xb1, 0x49,
0xb1, 0x87, 0x29, 0x31, 0x47, 0x3d, 0xac, 0xe7, 0x85, 0xa3, 0xed, 0x57, 0xdf, 0xb4, 0xfb, 0x7a, 0xba, 0x7d, 0x7d, 0x0f, 0xed, 0x43, 0xf1, 0x0c, 0x3b, 0xc4, 0x1c, 0x9d, 0x61, 0xbd, 0xc0, 0x15,
0xa1, 0xfe, 0x0a, 0xb6, 0x6f, 0x55, 0x05, 0x90, 0xd9, 0xf9, 0x88, 0x6a, 0x09, 0x0e, 0xcc, 0xe1, 0x65, 0x4f, 0x7d, 0xd3, 0xee, 0xeb, 0x5a, 0xe3, 0x1b, 0xc8, 0xde, 0x65, 0x07, 0x80, 0xcc, 0xee,
0xd0, 0xfa, 0x21, 0xd1, 0xed, 0xe2, 0xd1, 0xb5, 0x9e, 0xab, 0x7f, 0x0b, 0xfb, 0x0f, 0x44, 0x05, 0x23, 0x5d, 0x4b, 0xb0, 0x67, 0x0e, 0x87, 0xd6, 0x4f, 0x69, 0xdf, 0x1e, 0x1e, 0x5d, 0xea, 0x72,
0x90, 0xf0, 0x83, 0x49, 0x86, 0x5a, 0x86, 0x02, 0xc1, 0x57, 0x13, 0x6c, 0xd3, 0x24, 0x4e, 0xab, 0xe3, 0x7b, 0xd8, 0x7d, 0x8f, 0x1c, 0x00, 0xe2, 0x7a, 0x30, 0xc9, 0x51, 0xcb, 0xa0, 0x11, 0xfc,
0xfd, 0x1d, 0xee, 0x50, 0x3d, 0xd7, 0x7e, 0xfb, 0xd7, 0xfd, 0xb1, 0xf2, 0xf7, 0xfd, 0xb1, 0xf2, 0x66, 0x82, 0x6d, 0x27, 0xb5, 0xd3, 0xea, 0xfc, 0x80, 0xbb, 0x8e, 0x2e, 0x77, 0x2e, 0xfe, 0xba,
0xcf, 0xfd, 0xb1, 0xf2, 0xfb, 0xbf, 0xc7, 0xcf, 0x7e, 0xfc, 0x6a, 0xe9, 0xc6, 0x37, 0x77, 0x33, 0x3d, 0x94, 0xfe, 0xbe, 0x3d, 0x94, 0xfe, 0xb9, 0x3d, 0x94, 0xfe, 0xf8, 0xf7, 0xf0, 0xc9, 0xcf,
0xc3, 0x09, 0x6e, 0x9b, 0x7e, 0xb4, 0x72, 0x9c, 0xc6, 0x9c, 0xaf, 0x9b, 0x3e, 0x0f, 0x16, 0x51, 0x2f, 0x96, 0x5e, 0x72, 0x75, 0x33, 0x33, 0xdc, 0xf0, 0xba, 0x15, 0xc4, 0x2b, 0xd7, 0x6d, 0xce,
0x83, 0xad, 0xdc, 0xc6, 0x32, 0x68, 0xee, 0xfd, 0x07, 0x7c, 0xc3, 0x1c, 0xef, 0x8f, 0x9c, 0x3e, 0xd9, 0xba, 0x15, 0xb0, 0x70, 0x11, 0x37, 0xe9, 0xca, 0x6b, 0x2e, 0xc3, 0xd6, 0xce, 0x37, 0xe2,
0xe2, 0xc1, 0x85, 0x6d, 0x98, 0xe3, 0x81, 0xb8, 0x4e, 0xa6, 0xe3, 0xcd, 0xf2, 0xf2, 0xb1, 0x3f, 0x3b, 0xea, 0xfa, 0x7f, 0xca, 0xfa, 0x88, 0x85, 0xa7, 0xb6, 0x61, 0x8e, 0x07, 0xfc, 0x2a, 0x99,
0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x9c, 0x67, 0x62, 0x30, 0x06, 0x00, 0x00, 0xae, 0x3f, 0x2b, 0x88, 0x8f, 0xc1, 0xc9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x66, 0x66, 0x9c,
0x8f, 0x50, 0x06, 0x00, 0x00,
} }
func (m *EACLRecord) Marshal() (dAtA []byte, err error) { func (m *EACLRecord) Marshal() (dAtA []byte, err error) {
@ -809,7 +820,7 @@ func (m *EACLRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *EACLRecord_FilterInfo) Marshal() (dAtA []byte, err error) { func (m *EACLRecord_Filter) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -819,12 +830,12 @@ func (m *EACLRecord_FilterInfo) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *EACLRecord_FilterInfo) MarshalTo(dAtA []byte) (int, error) { func (m *EACLRecord_Filter) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *EACLRecord_FilterInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *EACLRecord_Filter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -852,15 +863,15 @@ func (m *EACLRecord_FilterInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i-- i--
dAtA[i] = 0x10 dAtA[i] = 0x10
} }
if m.Header != 0 { if m.HeaderType != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Header)) i = encodeVarintTypes(dAtA, i, uint64(m.HeaderType))
i-- i--
dAtA[i] = 0x8 dAtA[i] = 0x8
} }
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *EACLRecord_TargetInfo) Marshal() (dAtA []byte, err error) { func (m *EACLRecord_Target) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -870,12 +881,12 @@ func (m *EACLRecord_TargetInfo) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *EACLRecord_TargetInfo) MarshalTo(dAtA []byte) (int, error) { func (m *EACLRecord_Target) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *EACLRecord_TargetInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *EACLRecord_Target) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -893,8 +904,8 @@ func (m *EACLRecord_TargetInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
} }
} }
if m.Target != 0 { if m.Role != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Target)) i = encodeVarintTypes(dAtA, i, uint64(m.Role))
i-- i--
dAtA[i] = 0x8 dAtA[i] = 0x8
} }
@ -936,7 +947,7 @@ func (m *EACLTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintTypes(dAtA, i, uint64(size)) i = encodeVarintTypes(dAtA, i, uint64(size))
} }
i-- i--
dAtA[i] = 0x12 dAtA[i] = 0x1a
} }
} }
if m.ContainerId != nil { if m.ContainerId != nil {
@ -949,6 +960,18 @@ func (m *EACLTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintTypes(dAtA, i, uint64(size)) i = encodeVarintTypes(dAtA, i, uint64(size))
} }
i-- i--
dAtA[i] = 0x12
}
if m.Version != nil {
{
size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa dAtA[i] = 0xa
} }
return len(dAtA) - i, nil return len(dAtA) - i, nil
@ -1151,14 +1174,14 @@ func (m *EACLRecord) Size() (n int) {
return n return n
} }
func (m *EACLRecord_FilterInfo) Size() (n int) { func (m *EACLRecord_Filter) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
var l int var l int
_ = l _ = l
if m.Header != 0 { if m.HeaderType != 0 {
n += 1 + sovTypes(uint64(m.Header)) n += 1 + sovTypes(uint64(m.HeaderType))
} }
if m.MatchType != 0 { if m.MatchType != 0 {
n += 1 + sovTypes(uint64(m.MatchType)) n += 1 + sovTypes(uint64(m.MatchType))
@ -1177,14 +1200,14 @@ func (m *EACLRecord_FilterInfo) Size() (n int) {
return n return n
} }
func (m *EACLRecord_TargetInfo) Size() (n int) { func (m *EACLRecord_Target) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
var l int var l int
_ = l _ = l
if m.Target != 0 { if m.Role != 0 {
n += 1 + sovTypes(uint64(m.Target)) n += 1 + sovTypes(uint64(m.Role))
} }
if len(m.KeyList) > 0 { if len(m.KeyList) > 0 {
for _, b := range m.KeyList { for _, b := range m.KeyList {
@ -1204,6 +1227,10 @@ func (m *EACLTable) Size() (n int) {
} }
var l int var l int
_ = l _ = l
if m.Version != nil {
l = m.Version.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.ContainerId != nil { if m.ContainerId != nil {
l = m.ContainerId.Size() l = m.ContainerId.Size()
n += 1 + l + sovTypes(uint64(l)) n += 1 + l + sovTypes(uint64(l))
@ -1387,7 +1414,7 @@ func (m *EACLRecord) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Filters = append(m.Filters, &EACLRecord_FilterInfo{}) m.Filters = append(m.Filters, &EACLRecord_Filter{})
if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
@ -1421,7 +1448,7 @@ func (m *EACLRecord) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Targets = append(m.Targets, &EACLRecord_TargetInfo{}) m.Targets = append(m.Targets, &EACLRecord_Target{})
if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
@ -1451,7 +1478,7 @@ func (m *EACLRecord) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *EACLRecord_FilterInfo) Unmarshal(dAtA []byte) error { func (m *EACLRecord_Filter) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -1474,17 +1501,17 @@ func (m *EACLRecord_FilterInfo) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3) fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7) wireType := int(wire & 0x7)
if wireType == 4 { if wireType == 4 {
return fmt.Errorf("proto: FilterInfo: wiretype end group for non-group") return fmt.Errorf("proto: Filter: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: FilterInfo: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: Filter: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 0 { if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) return fmt.Errorf("proto: wrong wireType = %d for field HeaderType", wireType)
} }
m.Header = 0 m.HeaderType = 0
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowTypes return ErrIntOverflowTypes
@ -1494,7 +1521,7 @@ func (m *EACLRecord_FilterInfo) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
m.Header |= HeaderType(b&0x7F) << shift m.HeaderType |= HeaderType(b&0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
@ -1607,7 +1634,7 @@ func (m *EACLRecord_FilterInfo) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *EACLRecord_TargetInfo) Unmarshal(dAtA []byte) error { func (m *EACLRecord_Target) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -1630,17 +1657,17 @@ func (m *EACLRecord_TargetInfo) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3) fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7) wireType := int(wire & 0x7)
if wireType == 4 { if wireType == 4 {
return fmt.Errorf("proto: TargetInfo: wiretype end group for non-group") return fmt.Errorf("proto: Target: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: TargetInfo: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: Target: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 0 { if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
} }
m.Target = 0 m.Role = 0
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowTypes return ErrIntOverflowTypes
@ -1650,7 +1677,7 @@ func (m *EACLRecord_TargetInfo) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
m.Target |= Target(b&0x7F) << shift m.Role |= Role(b&0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
@ -1742,6 +1769,42 @@ func (m *EACLTable) Unmarshal(dAtA []byte) error {
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Version == nil {
m.Version = &grpc.Version{}
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType) return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
} }
@ -1777,7 +1840,7 @@ func (m *EACLTable) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 2: case 3:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
} }