github.com/zorawar87/trillian@v1.2.1/quota/etcd/storagepb/storagepb.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: storagepb.proto

package storagepb

/*
Package storagepb contains definitions for quota storage protos, which are recorded in etcd.
*/

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

// Possible states of a quota configuration.
type Config_State int32

const (
	// Unknown quota state. Invalid.
	Config_UNKNOWN_CONFIG_STATE Config_State = 0
	// Quota is enabled.
	Config_ENABLED Config_State = 1
	// Quota is disabled (considered infinite).
	Config_DISABLED Config_State = 2
)

var Config_State_name = map[int32]string{
	0: "UNKNOWN_CONFIG_STATE",
	1: "ENABLED",
	2: "DISABLED",
}
var Config_State_value = map[string]int32{
	"UNKNOWN_CONFIG_STATE": 0,
	"ENABLED":              1,
	"DISABLED":             2,
}

func (x Config_State) String() string {
	return proto.EnumName(Config_State_name, int32(x))
}
func (Config_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{2, 0}
}

// Data contained in a quota bucket.
// Stored at each each quota's zero bucket. For example,
// quotas/global/read/0 or quotas/trees/$id/read/0.
type Bucket struct {
	// Number of tokens left in the bucket.
	Tokens int64 `protobuf:"varint,1,opt,name=tokens" json:"tokens,omitempty"`
	// Timestamp of the last time the bucket got replenished.
	LastReplenishMillisSinceEpoch int64    `protobuf:"varint,2,opt,name=last_replenish_millis_since_epoch,json=lastReplenishMillisSinceEpoch" json:"last_replenish_millis_since_epoch,omitempty"`
	XXX_NoUnkeyedLiteral          struct{} `json:"-"`
	XXX_unrecognized              []byte   `json:"-"`
	XXX_sizecache                 int32    `json:"-"`
}

func (m *Bucket) Reset()         { *m = Bucket{} }
func (m *Bucket) String() string { return proto.CompactTextString(m) }
func (*Bucket) ProtoMessage()    {}
func (*Bucket) Descriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{0}
}
func (m *Bucket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Bucket.Unmarshal(m, b)
}
func (m *Bucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Bucket.Marshal(b, m, deterministic)
}
func (dst *Bucket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bucket.Merge(dst, src)
}
func (m *Bucket) XXX_Size() int {
	return xxx_messageInfo_Bucket.Size(m)
}
func (m *Bucket) XXX_DiscardUnknown() {
	xxx_messageInfo_Bucket.DiscardUnknown(m)
}

var xxx_messageInfo_Bucket proto.InternalMessageInfo

func (m *Bucket) GetTokens() int64 {
	if m != nil {
		return m.Tokens
	}
	return 0
}

func (m *Bucket) GetLastReplenishMillisSinceEpoch() int64 {
	if m != nil {
		return m.LastReplenishMillisSinceEpoch
	}
	return 0
}

// Configuration for all quotas.
// Stored at quotas/configs.
type Configs struct {
	// Known quota configurations.
	Configs              []*Config `protobuf:"bytes,1,rep,name=configs" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Configs) Reset()         { *m = Configs{} }
func (m *Configs) String() string { return proto.CompactTextString(m) }
func (*Configs) ProtoMessage()    {}
func (*Configs) Descriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{1}
}
func (m *Configs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Configs.Unmarshal(m, b)
}
func (m *Configs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Configs.Marshal(b, m, deterministic)
}
func (dst *Configs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configs.Merge(dst, src)
}
func (m *Configs) XXX_Size() int {
	return xxx_messageInfo_Configs.Size(m)
}
func (m *Configs) XXX_DiscardUnknown() {
	xxx_messageInfo_Configs.DiscardUnknown(m)
}

var xxx_messageInfo_Configs proto.InternalMessageInfo

func (m *Configs) GetConfigs() []*Config {
	if m != nil {
		return m.Configs
	}
	return nil
}

// Configuration of a quota.
type Config struct {
	// Name of the config, eg, “quotas/trees/1234/read/config”.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// State of the config.
	State Config_State `protobuf:"varint,2,opt,name=state,enum=storagepb.Config_State" json:"state,omitempty"`
	// Max number of tokens available for the config.
	MaxTokens int64 `protobuf:"varint,3,opt,name=max_tokens,json=maxTokens" json:"max_tokens,omitempty"`
	// Replenishment strategy used by the config.
	//
	// Types that are valid to be assigned to ReplenishmentStrategy:
	//	*Config_SequencingBased
	//	*Config_TimeBased
	ReplenishmentStrategy isConfig_ReplenishmentStrategy `protobuf_oneof:"replenishment_strategy"`
	XXX_NoUnkeyedLiteral  struct{}                       `json:"-"`
	XXX_unrecognized      []byte                         `json:"-"`
	XXX_sizecache         int32                          `json:"-"`
}

func (m *Config) Reset()         { *m = Config{} }
func (m *Config) String() string { return proto.CompactTextString(m) }
func (*Config) ProtoMessage()    {}
func (*Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{2}
}
func (m *Config) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Config.Unmarshal(m, b)
}
func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Config.Marshal(b, m, deterministic)
}
func (dst *Config) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Config.Merge(dst, src)
}
func (m *Config) XXX_Size() int {
	return xxx_messageInfo_Config.Size(m)
}
func (m *Config) XXX_DiscardUnknown() {
	xxx_messageInfo_Config.DiscardUnknown(m)
}

var xxx_messageInfo_Config proto.InternalMessageInfo

type isConfig_ReplenishmentStrategy interface {
	isConfig_ReplenishmentStrategy()
}

type Config_SequencingBased struct {
	SequencingBased *SequencingBasedStrategy `protobuf:"bytes,4,opt,name=sequencing_based,json=sequencingBased,oneof"`
}
type Config_TimeBased struct {
	TimeBased *TimeBasedStrategy `protobuf:"bytes,5,opt,name=time_based,json=timeBased,oneof"`
}

func (*Config_SequencingBased) isConfig_ReplenishmentStrategy() {}
func (*Config_TimeBased) isConfig_ReplenishmentStrategy()       {}

func (m *Config) GetReplenishmentStrategy() isConfig_ReplenishmentStrategy {
	if m != nil {
		return m.ReplenishmentStrategy
	}
	return nil
}

func (m *Config) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Config) GetState() Config_State {
	if m != nil {
		return m.State
	}
	return Config_UNKNOWN_CONFIG_STATE
}

func (m *Config) GetMaxTokens() int64 {
	if m != nil {
		return m.MaxTokens
	}
	return 0
}

func (m *Config) GetSequencingBased() *SequencingBasedStrategy {
	if x, ok := m.GetReplenishmentStrategy().(*Config_SequencingBased); ok {
		return x.SequencingBased
	}
	return nil
}

func (m *Config) GetTimeBased() *TimeBasedStrategy {
	if x, ok := m.GetReplenishmentStrategy().(*Config_TimeBased); ok {
		return x.TimeBased
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Config) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Config_OneofMarshaler, _Config_OneofUnmarshaler, _Config_OneofSizer, []interface{}{
		(*Config_SequencingBased)(nil),
		(*Config_TimeBased)(nil),
	}
}

func _Config_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Config)
	// replenishment_strategy
	switch x := m.ReplenishmentStrategy.(type) {
	case *Config_SequencingBased:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.SequencingBased); err != nil {
			return err
		}
	case *Config_TimeBased:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TimeBased); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Config.ReplenishmentStrategy has unexpected type %T", x)
	}
	return nil
}

func _Config_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Config)
	switch tag {
	case 4: // replenishment_strategy.sequencing_based
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SequencingBasedStrategy)
		err := b.DecodeMessage(msg)
		m.ReplenishmentStrategy = &Config_SequencingBased{msg}
		return true, err
	case 5: // replenishment_strategy.time_based
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TimeBasedStrategy)
		err := b.DecodeMessage(msg)
		m.ReplenishmentStrategy = &Config_TimeBased{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Config_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Config)
	// replenishment_strategy
	switch x := m.ReplenishmentStrategy.(type) {
	case *Config_SequencingBased:
		s := proto.Size(x.SequencingBased)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Config_TimeBased:
		s := proto.Size(x.TimeBased)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Sequencing-based replenishment strategy settings.
type SequencingBasedStrategy struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SequencingBasedStrategy) Reset()         { *m = SequencingBasedStrategy{} }
func (m *SequencingBasedStrategy) String() string { return proto.CompactTextString(m) }
func (*SequencingBasedStrategy) ProtoMessage()    {}
func (*SequencingBasedStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{3}
}
func (m *SequencingBasedStrategy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SequencingBasedStrategy.Unmarshal(m, b)
}
func (m *SequencingBasedStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SequencingBasedStrategy.Marshal(b, m, deterministic)
}
func (dst *SequencingBasedStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SequencingBasedStrategy.Merge(dst, src)
}
func (m *SequencingBasedStrategy) XXX_Size() int {
	return xxx_messageInfo_SequencingBasedStrategy.Size(m)
}
func (m *SequencingBasedStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_SequencingBasedStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_SequencingBasedStrategy proto.InternalMessageInfo

// Time-based replenishment strategy settings.
type TimeBasedStrategy struct {
	// Number of tokens to replenish at every replenish_interval_seconds.
	TokensToReplenish int64 `protobuf:"varint,1,opt,name=tokens_to_replenish,json=tokensToReplenish" json:"tokens_to_replenish,omitempty"`
	// Interval at which tokens_to_replenish get replenished.
	ReplenishIntervalSeconds int64    `protobuf:"varint,2,opt,name=replenish_interval_seconds,json=replenishIntervalSeconds" json:"replenish_interval_seconds,omitempty"`
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_unrecognized         []byte   `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

func (m *TimeBasedStrategy) Reset()         { *m = TimeBasedStrategy{} }
func (m *TimeBasedStrategy) String() string { return proto.CompactTextString(m) }
func (*TimeBasedStrategy) ProtoMessage()    {}
func (*TimeBasedStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_storagepb_7b621c1201af4753, []int{4}
}
func (m *TimeBasedStrategy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TimeBasedStrategy.Unmarshal(m, b)
}
func (m *TimeBasedStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TimeBasedStrategy.Marshal(b, m, deterministic)
}
func (dst *TimeBasedStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TimeBasedStrategy.Merge(dst, src)
}
func (m *TimeBasedStrategy) XXX_Size() int {
	return xxx_messageInfo_TimeBasedStrategy.Size(m)
}
func (m *TimeBasedStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_TimeBasedStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_TimeBasedStrategy proto.InternalMessageInfo

func (m *TimeBasedStrategy) GetTokensToReplenish() int64 {
	if m != nil {
		return m.TokensToReplenish
	}
	return 0
}

func (m *TimeBasedStrategy) GetReplenishIntervalSeconds() int64 {
	if m != nil {
		return m.ReplenishIntervalSeconds
	}
	return 0
}

func init() {
	proto.RegisterType((*Bucket)(nil), "storagepb.Bucket")
	proto.RegisterType((*Configs)(nil), "storagepb.Configs")
	proto.RegisterType((*Config)(nil), "storagepb.Config")
	proto.RegisterType((*SequencingBasedStrategy)(nil), "storagepb.SequencingBasedStrategy")
	proto.RegisterType((*TimeBasedStrategy)(nil), "storagepb.TimeBasedStrategy")
	proto.RegisterEnum("storagepb.Config_State", Config_State_name, Config_State_value)
}

func init() { proto.RegisterFile("storagepb.proto", fileDescriptor_storagepb_7b621c1201af4753) }

var fileDescriptor_storagepb_7b621c1201af4753 = []byte{
	// 422 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xc1, 0x6f, 0xd3, 0x30,
	0x14, 0xc6, 0x97, 0x76, 0x6d, 0xe9, 0x2b, 0x62, 0xad, 0x41, 0x5b, 0x40, 0x4c, 0x2a, 0x39, 0x55,
	0x42, 0xe4, 0x50, 0x24, 0x4e, 0xe3, 0xb0, 0x6c, 0x81, 0x55, 0x40, 0x2a, 0x25, 0x41, 0x1c, 0x2d,
	0x37, 0x7b, 0x64, 0x66, 0x89, 0x1d, 0x62, 0x0f, 0x8d, 0x23, 0xff, 0x22, 0x7f, 0x11, 0x8a, 0x9d,
	0xa6, 0x83, 0x89, 0x9b, 0xfd, 0xde, 0x2f, 0x5f, 0xbe, 0xe7, 0xf7, 0xc1, 0x81, 0xd2, 0xb2, 0x66,
	0x39, 0x56, 0x1b, 0xbf, 0xaa, 0xa5, 0x96, 0x64, 0xdc, 0x15, 0xbc, 0x6f, 0x30, 0x0c, 0x6e, 0xb2,
	0x6b, 0xd4, 0xe4, 0x10, 0x86, 0x5a, 0x5e, 0xa3, 0x50, 0xae, 0x33, 0x77, 0x16, 0xfd, 0xb8, 0xbd,
	0x91, 0x0b, 0x78, 0x51, 0x30, 0xa5, 0x69, 0x8d, 0x55, 0x81, 0x82, 0xab, 0x2b, 0x5a, 0xf2, 0xa2,
	0xe0, 0x8a, 0x2a, 0x2e, 0x32, 0xa4, 0x58, 0xc9, 0xec, 0xca, 0xed, 0x99, 0x4f, 0x8e, 0x1b, 0x30,
	0xde, 0x72, 0x9f, 0x0c, 0x96, 0x34, 0x54, 0xd8, 0x40, 0xde, 0x1b, 0x18, 0x9d, 0x49, 0xf1, 0x95,
	0xe7, 0x8a, 0xbc, 0x84, 0x51, 0x66, 0x8f, 0xae, 0x33, 0xef, 0x2f, 0x26, 0xcb, 0x99, 0xbf, 0x33,
	0x69, 0xa1, 0x78, 0x4b, 0x78, 0xbf, 0x7b, 0x30, 0xb4, 0x35, 0x42, 0x60, 0x5f, 0xb0, 0x12, 0x8d,
	0xc5, 0x71, 0x6c, 0xce, 0xe4, 0x15, 0x0c, 0x94, 0x66, 0x1a, 0x8d, 0x89, 0x47, 0xcb, 0xa3, 0x7b,
	0x4a, 0x7e, 0xd2, 0xb4, 0x63, 0x4b, 0x91, 0x63, 0x80, 0x92, 0xdd, 0xd2, 0x76, 0xd6, 0xbe, 0x31,
	0x3e, 0x2e, 0xd9, 0x6d, 0x6a, 0xc7, 0x5d, 0xc3, 0x54, 0xe1, 0xf7, 0x1b, 0x14, 0x19, 0x17, 0x39,
	0xdd, 0x30, 0x85, 0x97, 0xee, 0xfe, 0xdc, 0x59, 0x4c, 0x96, 0xde, 0x1d, 0xe1, 0xa4, 0x43, 0x82,
	0x86, 0x48, 0x74, 0xcd, 0x34, 0xe6, 0x3f, 0x2f, 0xf6, 0xe2, 0x03, 0xf5, 0x77, 0x8b, 0xbc, 0x05,
	0xd0, 0xbc, 0xc4, 0x56, 0x6a, 0x60, 0xa4, 0x9e, 0xdf, 0x91, 0x4a, 0x79, 0x89, 0xff, 0x8a, 0x8c,
	0xf5, 0xb6, 0xe8, 0x9d, 0xc0, 0xc0, 0xd8, 0x27, 0x2e, 0x3c, 0xf9, 0x1c, 0x7d, 0x88, 0xd6, 0x5f,
	0x22, 0x7a, 0xb6, 0x8e, 0xde, 0xad, 0xde, 0xd3, 0x24, 0x3d, 0x4d, 0xc3, 0xe9, 0x1e, 0x99, 0xc0,
	0x28, 0x8c, 0x4e, 0x83, 0x8f, 0xe1, 0xf9, 0xd4, 0x21, 0x0f, 0xe1, 0xc1, 0xf9, 0x2a, 0xb1, 0xb7,
	0x5e, 0xe0, 0xc2, 0x61, 0xb7, 0xb7, 0x12, 0x85, 0xa6, 0xaa, 0xfd, 0x89, 0xf7, 0x14, 0x8e, 0xfe,
	0x33, 0x84, 0xf7, 0xcb, 0x81, 0xd9, 0x3d, 0x57, 0xc4, 0x87, 0xc7, 0xf6, 0xcd, 0xa8, 0x96, 0xbb,
	0x30, 0xb4, 0x61, 0x99, 0xd9, 0x56, 0x2a, 0xbb, 0xed, 0x93, 0x13, 0x78, 0xb6, 0x8b, 0x0c, 0x17,
	0x1a, 0xeb, 0x1f, 0xac, 0xa0, 0x0a, 0x33, 0x29, 0x2e, 0x55, 0x1b, 0x18, 0xb7, 0x23, 0x56, 0x2d,
	0x90, 0xd8, 0xfe, 0x66, 0x68, 0x92, 0xfa, 0xfa, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x4a,
	0xd5, 0x29, 0xbc, 0x02, 0x00, 0x00,
}