diff --git a/.gitignore b/.gitignore index d27d9f8..bbfa5fb 100644 --- a/.gitignore +++ b/.gitignore @@ -133,5 +133,9 @@ docs/_build/ site/ *.md !README.md +!docs/*.md +docs/PAPER.md +docs/DEPLOYMENT.md +docs/USAGE.md .qwen/ *.docx diff --git a/go.mod b/go.mod index f4fca2a..8931d7f 100644 --- a/go.mod +++ b/go.mod @@ -23,6 +23,7 @@ require ( github.com/clipperhouse/uax29/v2 v2.6.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/klauspost/compress v1.18.5 // indirect github.com/kr/text v0.2.0 // indirect github.com/mattn/go-colorable v0.1.14 // indirect github.com/mattn/go-isatty v0.0.20 // indirect @@ -31,12 +32,16 @@ require ( github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 // indirect github.com/olekukonko/errors v1.2.0 // indirect github.com/olekukonko/ll v0.1.6 // indirect + github.com/philhofer/fwd v1.2.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.66.1 // indirect github.com/prometheus/procfs v0.16.1 // indirect github.com/spf13/pflag v1.0.9 // indirect + github.com/tinylib/msgp v1.6.4 // indirect go.yaml.in/yaml/v2 v2.4.2 // indirect + golang.org/x/mod v0.18.0 // indirect golang.org/x/sys v0.35.0 // indirect + golang.org/x/tools v0.22.0 // indirect google.golang.org/protobuf v1.36.8 // indirect ) diff --git a/go.sum b/go.sum index bb45bb4..d8a3104 100644 --- a/go.sum +++ b/go.sum @@ -26,6 +26,8 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE= +github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -50,6 +52,8 @@ github.com/olekukonko/ll v0.1.6 h1:lGVTHO+Qc4Qm+fce/2h2m5y9LvqaW+DCN7xW9hsU3uA= github.com/olekukonko/ll v0.1.6/go.mod h1:NVUmjBb/aCtUpjKk75BhWrOlARz3dqsM+OtszpY4o88= github.com/olekukonko/tablewriter v1.1.4 h1:ORUMI3dXbMnRlRggJX3+q7OzQFDdvgbN9nVWj1drm6I= github.com/olekukonko/tablewriter v1.1.4/go.mod h1:+kedxuyTtgoZLwif3P1Em4hARJs+mVnzKxmsCL/C5RY= +github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= +github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= @@ -69,15 +73,21 @@ github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY= github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ= +github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= +golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= +golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc= google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/internal/cluster/hintstore_msgp.go b/internal/cluster/hintstore_msgp.go new file mode 100644 index 0000000..183ae09 --- /dev/null +++ b/internal/cluster/hintstore_msgp.go @@ -0,0 +1,299 @@ +// Code generated by github.com/tinylib/msgp DO NOT EDIT. + +package cluster + +import ( + "github.com/tinylib/msgp/msgp" +) + +// DecodeMsg implements msgp.Decodable +func (z *Hint) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "TargetNode": + z.TargetNode, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "TargetNode") + return + } + case "CreatedAt": + z.CreatedAt, err = dc.ReadTime() + if err != nil { + err = msgp.WrapError(err, "CreatedAt") + return + } + case "Attempts": + var zb0002 int32 + zb0002, err = dc.ReadInt32() + z.Attempts.Store(zb0002) + if err != nil { + err = msgp.WrapError(err, "Attempts") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *Hint) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 5 + // write "Key" + err = en.Append(0x85, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + // write "TargetNode" + err = en.Append(0xaa, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65) + if err != nil { + return + } + err = en.WriteString(z.TargetNode) + if err != nil { + err = msgp.WrapError(err, "TargetNode") + return + } + // write "CreatedAt" + err = en.Append(0xa9, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74) + if err != nil { + return + } + err = en.WriteTime(z.CreatedAt) + if err != nil { + err = msgp.WrapError(err, "CreatedAt") + return + } + // write "Attempts" + err = en.Append(0xa8, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73) + if err != nil { + return + } + err = en.WriteInt32(z.Attempts.Load()) + if err != nil { + err = msgp.WrapError(err, "Attempts") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *Hint) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 5 + // string "Key" + o = append(o, 0x85, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + // string "TargetNode" + o = append(o, 0xaa, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65) + o = msgp.AppendString(o, z.TargetNode) + // string "CreatedAt" + o = append(o, 0xa9, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74) + o = msgp.AppendTime(o, z.CreatedAt) + // string "Attempts" + o = append(o, 0xa8, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73) + o = msgp.AppendInt32(o, z.Attempts.Load()) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *Hint) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "TargetNode": + z.TargetNode, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "TargetNode") + return + } + case "CreatedAt": + z.CreatedAt, bts, err = msgp.ReadTimeBytes(bts) + if err != nil { + err = msgp.WrapError(err, "CreatedAt") + return + } + case "Attempts": + var zb0002 int32 + zb0002, bts, err = msgp.ReadInt32Bytes(bts) + z.Attempts.Store(zb0002) + if err != nil { + err = msgp.WrapError(err, "Attempts") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *Hint) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.BytesPrefixSize + len(z.Value) + 11 + msgp.StringPrefixSize + len(z.TargetNode) + 10 + msgp.TimeSize + 9 + msgp.Int32Size + return +} + +// DecodeMsg implements msgp.Decodable +func (z *HintStore) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z HintStore) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 0 + _ = z + err = en.Append(0x80) + if err != nil { + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z HintStore) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 0 + _ = z + o = append(o, 0x80) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *HintStore) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z HintStore) Msgsize() (s int) { + s = 1 + return +} diff --git a/internal/rpc/batch_msgp.go b/internal/rpc/batch_msgp.go new file mode 100644 index 0000000..e34489d --- /dev/null +++ b/internal/rpc/batch_msgp.go @@ -0,0 +1,1027 @@ +// Code generated by github.com/tinylib/msgp DO NOT EDIT. + +package rpc + +import ( + "github.com/tinylib/msgp/msgp" +) + +// DecodeMsg implements msgp.Decodable +func (z *BatchReadEntry) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Found": + z.Found, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + case "Tombstone": + z.Tombstone, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *BatchReadEntry) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 4 + // write "Key" + err = en.Append(0x84, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + // write "Found" + err = en.Append(0xa5, 0x46, 0x6f, 0x75, 0x6e, 0x64) + if err != nil { + return + } + err = en.WriteBool(z.Found) + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + // write "Tombstone" + err = en.Append(0xa9, 0x54, 0x6f, 0x6d, 0x62, 0x73, 0x74, 0x6f, 0x6e, 0x65) + if err != nil { + return + } + err = en.WriteBool(z.Tombstone) + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *BatchReadEntry) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 4 + // string "Key" + o = append(o, 0x84, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + // string "Found" + o = append(o, 0xa5, 0x46, 0x6f, 0x75, 0x6e, 0x64) + o = msgp.AppendBool(o, z.Found) + // string "Tombstone" + o = append(o, 0xa9, 0x54, 0x6f, 0x6d, 0x62, 0x73, 0x74, 0x6f, 0x6e, 0x65) + o = msgp.AppendBool(o, z.Tombstone) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchReadEntry) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Found": + z.Found, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + case "Tombstone": + z.Tombstone, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *BatchReadEntry) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.BytesPrefixSize + len(z.Value) + 6 + msgp.BoolSize + 10 + msgp.BoolSize + return +} + +// DecodeMsg implements msgp.Decodable +func (z *BatchReadRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Keys": + var zb0002 uint32 + zb0002, err = dc.ReadArrayHeader() + if err != nil { + err = msgp.WrapError(err, "Keys") + return + } + if cap(z.Keys) >= int(zb0002) { + z.Keys = (z.Keys)[:zb0002] + } else { + z.Keys = make([]string, zb0002) + } + for za0001 := range z.Keys { + z.Keys[za0001], err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Keys", za0001) + return + } + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *BatchReadRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Keys" + err = en.Append(0x81, 0xa4, 0x4b, 0x65, 0x79, 0x73) + if err != nil { + return + } + err = en.WriteArrayHeader(uint32(len(z.Keys))) + if err != nil { + err = msgp.WrapError(err, "Keys") + return + } + for za0001 := range z.Keys { + err = en.WriteString(z.Keys[za0001]) + if err != nil { + err = msgp.WrapError(err, "Keys", za0001) + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *BatchReadRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Keys" + o = append(o, 0x81, 0xa4, 0x4b, 0x65, 0x79, 0x73) + o = msgp.AppendArrayHeader(o, uint32(len(z.Keys))) + for za0001 := range z.Keys { + o = msgp.AppendString(o, z.Keys[za0001]) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchReadRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Keys": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Keys") + return + } + if cap(z.Keys) >= int(zb0002) { + z.Keys = (z.Keys)[:zb0002] + } else { + z.Keys = make([]string, zb0002) + } + for za0001 := range z.Keys { + z.Keys[za0001], bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Keys", za0001) + return + } + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *BatchReadRequest) Msgsize() (s int) { + s = 1 + 5 + msgp.ArrayHeaderSize + for za0001 := range z.Keys { + s += msgp.StringPrefixSize + len(z.Keys[za0001]) + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *BatchReadResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Entries": + var zb0002 uint32 + zb0002, err = dc.ReadArrayHeader() + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + if cap(z.Entries) >= int(zb0002) { + z.Entries = (z.Entries)[:zb0002] + } else { + z.Entries = make([]BatchReadEntry, zb0002) + } + for za0001 := range z.Entries { + err = z.Entries[za0001].DecodeMsg(dc) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + case "Error": + z.Error, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *BatchReadResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "Success" + err = en.Append(0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + if err != nil { + return + } + err = en.WriteBool(z.Success) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + // write "Entries" + err = en.Append(0xa7, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteArrayHeader(uint32(len(z.Entries))) + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + for za0001 := range z.Entries { + err = z.Entries[za0001].EncodeMsg(en) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + // write "Error" + err = en.Append(0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Error) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *BatchReadResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "Success" + o = append(o, 0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + o = msgp.AppendBool(o, z.Success) + // string "Entries" + o = append(o, 0xa7, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73) + o = msgp.AppendArrayHeader(o, uint32(len(z.Entries))) + for za0001 := range z.Entries { + o, err = z.Entries[za0001].MarshalMsg(o) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + // string "Error" + o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + o = msgp.AppendString(o, z.Error) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchReadResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Entries": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + if cap(z.Entries) >= int(zb0002) { + z.Entries = (z.Entries)[:zb0002] + } else { + z.Entries = make([]BatchReadEntry, zb0002) + } + for za0001 := range z.Entries { + bts, err = z.Entries[za0001].UnmarshalMsg(bts) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + case "Error": + z.Error, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *BatchReadResponse) Msgsize() (s int) { + s = 1 + 8 + msgp.BoolSize + 8 + msgp.ArrayHeaderSize + for za0001 := range z.Entries { + s += z.Entries[za0001].Msgsize() + } + s += 6 + msgp.StringPrefixSize + len(z.Error) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *BatchWriteEntry) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *BatchWriteEntry) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 2 + // write "Key" + err = en.Append(0x82, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *BatchWriteEntry) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 2 + // string "Key" + o = append(o, 0x82, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchWriteEntry) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *BatchWriteEntry) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.BytesPrefixSize + len(z.Value) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *BatchWriteRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Entries": + var zb0002 uint32 + zb0002, err = dc.ReadArrayHeader() + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + if cap(z.Entries) >= int(zb0002) { + z.Entries = (z.Entries)[:zb0002] + } else { + z.Entries = make([]BatchWriteEntry, zb0002) + } + for za0001 := range z.Entries { + var zb0003 uint32 + zb0003, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + for zb0003 > 0 { + zb0003-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Entries[za0001].Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Key") + return + } + case "Value": + z.Entries[za0001].Value, err = dc.ReadBytes(z.Entries[za0001].Value) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Value") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + } + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *BatchWriteRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Entries" + err = en.Append(0x81, 0xa7, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteArrayHeader(uint32(len(z.Entries))) + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + for za0001 := range z.Entries { + // map header, size 2 + // write "Key" + err = en.Append(0x82, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Entries[za0001].Key) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Entries[za0001].Value) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Value") + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *BatchWriteRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Entries" + o = append(o, 0x81, 0xa7, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73) + o = msgp.AppendArrayHeader(o, uint32(len(z.Entries))) + for za0001 := range z.Entries { + // map header, size 2 + // string "Key" + o = append(o, 0x82, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Entries[za0001].Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Entries[za0001].Value) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchWriteRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Entries": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Entries") + return + } + if cap(z.Entries) >= int(zb0002) { + z.Entries = (z.Entries)[:zb0002] + } else { + z.Entries = make([]BatchWriteEntry, zb0002) + } + for za0001 := range z.Entries { + var zb0003 uint32 + zb0003, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + for zb0003 > 0 { + zb0003-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Entries[za0001].Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Key") + return + } + case "Value": + z.Entries[za0001].Value, bts, err = msgp.ReadBytesBytes(bts, z.Entries[za0001].Value) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001, "Value") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err, "Entries", za0001) + return + } + } + } + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *BatchWriteRequest) Msgsize() (s int) { + s = 1 + 8 + msgp.ArrayHeaderSize + for za0001 := range z.Entries { + s += 1 + 4 + msgp.StringPrefixSize + len(z.Entries[za0001].Key) + 6 + msgp.BytesPrefixSize + len(z.Entries[za0001].Value) + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *BatchWriteResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Applied": + z.Applied, err = dc.ReadInt() + if err != nil { + err = msgp.WrapError(err, "Applied") + return + } + case "Error": + z.Error, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z BatchWriteResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "Success" + err = en.Append(0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + if err != nil { + return + } + err = en.WriteBool(z.Success) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + // write "Applied" + err = en.Append(0xa7, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64) + if err != nil { + return + } + err = en.WriteInt(z.Applied) + if err != nil { + err = msgp.WrapError(err, "Applied") + return + } + // write "Error" + err = en.Append(0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Error) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z BatchWriteResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "Success" + o = append(o, 0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + o = msgp.AppendBool(o, z.Success) + // string "Applied" + o = append(o, 0xa7, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64) + o = msgp.AppendInt(o, z.Applied) + // string "Error" + o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + o = msgp.AppendString(o, z.Error) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *BatchWriteResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Applied": + z.Applied, bts, err = msgp.ReadIntBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Applied") + return + } + case "Error": + z.Error, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z BatchWriteResponse) Msgsize() (s int) { + s = 1 + 8 + msgp.BoolSize + 8 + msgp.IntSize + 6 + msgp.StringPrefixSize + len(z.Error) + return +} diff --git a/internal/rpc/client.go b/internal/rpc/client.go index e297dec..c6eb518 100644 --- a/internal/rpc/client.go +++ b/internal/rpc/client.go @@ -184,11 +184,11 @@ func (c *Client) doRequest(ctx context.Context, method, url string, body, result var reqBody io.Reader if body != nil { - jsonData, err := json.Marshal(body) + data, err := json.Marshal(body) if err != nil { return fmt.Errorf("failed to marshal request: %w", err) } - reqBody = bytes.NewReader(jsonData) + reqBody = bytes.NewReader(data) } req, err := http.NewRequestWithContext(ctx, method, url, reqBody) diff --git a/internal/rpc/client_msgp.go b/internal/rpc/client_msgp.go new file mode 100644 index 0000000..3df4a2f --- /dev/null +++ b/internal/rpc/client_msgp.go @@ -0,0 +1,1671 @@ +// Code generated by github.com/tinylib/msgp DO NOT EDIT. + +package rpc + +import ( + "github.com/tinylib/msgp/msgp" +) + +// DecodeMsg implements msgp.Decodable +func (z *Client) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z Client) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 0 + _ = z + err = en.Append(0x80) + if err != nil { + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z Client) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 0 + _ = z + o = append(o, 0x80) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *Client) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z Client) Msgsize() (s int) { + s = 1 + return +} + +// DecodeMsg implements msgp.Decodable +func (z *GossipRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Members": + var zb0002 uint32 + zb0002, err = dc.ReadArrayHeader() + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + if cap(z.Members) >= int(zb0002) { + z.Members = (z.Members)[:zb0002] + } else { + z.Members = make([]string, zb0002) + } + for za0001 := range z.Members { + z.Members[za0001], err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *GossipRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Members" + err = en.Append(0x81, 0xa7, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73) + if err != nil { + return + } + err = en.WriteArrayHeader(uint32(len(z.Members))) + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + for za0001 := range z.Members { + err = en.WriteString(z.Members[za0001]) + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *GossipRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Members" + o = append(o, 0x81, 0xa7, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73) + o = msgp.AppendArrayHeader(o, uint32(len(z.Members))) + for za0001 := range z.Members { + o = msgp.AppendString(o, z.Members[za0001]) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *GossipRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Members": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + if cap(z.Members) >= int(zb0002) { + z.Members = (z.Members)[:zb0002] + } else { + z.Members = make([]string, zb0002) + } + for za0001 := range z.Members { + z.Members[za0001], bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *GossipRequest) Msgsize() (s int) { + s = 1 + 8 + msgp.ArrayHeaderSize + for za0001 := range z.Members { + s += msgp.StringPrefixSize + len(z.Members[za0001]) + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *GossipResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Members": + var zb0002 uint32 + zb0002, err = dc.ReadArrayHeader() + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + if cap(z.Members) >= int(zb0002) { + z.Members = (z.Members)[:zb0002] + } else { + z.Members = make([]string, zb0002) + } + for za0001 := range z.Members { + z.Members[za0001], err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *GossipResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Members" + err = en.Append(0x81, 0xa7, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73) + if err != nil { + return + } + err = en.WriteArrayHeader(uint32(len(z.Members))) + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + for za0001 := range z.Members { + err = en.WriteString(z.Members[za0001]) + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *GossipResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Members" + o = append(o, 0x81, 0xa7, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73) + o = msgp.AppendArrayHeader(o, uint32(len(z.Members))) + for za0001 := range z.Members { + o = msgp.AppendString(o, z.Members[za0001]) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *GossipResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Members": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Members") + return + } + if cap(z.Members) >= int(zb0002) { + z.Members = (z.Members)[:zb0002] + } else { + z.Members = make([]string, zb0002) + } + for za0001 := range z.Members { + z.Members[za0001], bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Members", za0001) + return + } + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *GossipResponse) Msgsize() (s int) { + s = 1 + 8 + msgp.ArrayHeaderSize + for za0001 := range z.Members { + s += msgp.StringPrefixSize + len(z.Members[za0001]) + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *NodeInfoResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "NodeID": + z.NodeID, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "NodeID") + return + } + case "Addr": + z.Addr, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Addr") + return + } + case "Stats": + var zb0002 uint32 + zb0002, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + for zb0002 > 0 { + zb0002-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + switch msgp.UnsafeString(field) { + case "KeyCount": + z.Stats.KeyCount, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "Stats", "KeyCount") + return + } + case "DiskBytes": + z.Stats.DiskBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "Stats", "DiskBytes") + return + } + case "MemBytes": + z.Stats.MemBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "Stats", "MemBytes") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + } + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *NodeInfoResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "NodeID" + err = en.Append(0x83, 0xa6, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44) + if err != nil { + return + } + err = en.WriteString(z.NodeID) + if err != nil { + err = msgp.WrapError(err, "NodeID") + return + } + // write "Addr" + err = en.Append(0xa4, 0x41, 0x64, 0x64, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Addr) + if err != nil { + err = msgp.WrapError(err, "Addr") + return + } + // write "Stats" + err = en.Append(0xa5, 0x53, 0x74, 0x61, 0x74, 0x73) + if err != nil { + return + } + // map header, size 3 + // write "KeyCount" + err = en.Append(0x83, 0xa8, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74) + if err != nil { + return + } + err = en.WriteInt64(z.Stats.KeyCount) + if err != nil { + err = msgp.WrapError(err, "Stats", "KeyCount") + return + } + // write "DiskBytes" + err = en.Append(0xa9, 0x44, 0x69, 0x73, 0x6b, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.Stats.DiskBytes) + if err != nil { + err = msgp.WrapError(err, "Stats", "DiskBytes") + return + } + // write "MemBytes" + err = en.Append(0xa8, 0x4d, 0x65, 0x6d, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.Stats.MemBytes) + if err != nil { + err = msgp.WrapError(err, "Stats", "MemBytes") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *NodeInfoResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "NodeID" + o = append(o, 0x83, 0xa6, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44) + o = msgp.AppendString(o, z.NodeID) + // string "Addr" + o = append(o, 0xa4, 0x41, 0x64, 0x64, 0x72) + o = msgp.AppendString(o, z.Addr) + // string "Stats" + o = append(o, 0xa5, 0x53, 0x74, 0x61, 0x74, 0x73) + // map header, size 3 + // string "KeyCount" + o = append(o, 0x83, 0xa8, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74) + o = msgp.AppendInt64(o, z.Stats.KeyCount) + // string "DiskBytes" + o = append(o, 0xa9, 0x44, 0x69, 0x73, 0x6b, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.Stats.DiskBytes) + // string "MemBytes" + o = append(o, 0xa8, 0x4d, 0x65, 0x6d, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.Stats.MemBytes) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *NodeInfoResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "NodeID": + z.NodeID, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "NodeID") + return + } + case "Addr": + z.Addr, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Addr") + return + } + case "Stats": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + for zb0002 > 0 { + zb0002-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + switch msgp.UnsafeString(field) { + case "KeyCount": + z.Stats.KeyCount, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "Stats", "KeyCount") + return + } + case "DiskBytes": + z.Stats.DiskBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "Stats", "DiskBytes") + return + } + case "MemBytes": + z.Stats.MemBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "Stats", "MemBytes") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err, "Stats") + return + } + } + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *NodeInfoResponse) Msgsize() (s int) { + s = 1 + 7 + msgp.StringPrefixSize + len(z.NodeID) + 5 + msgp.StringPrefixSize + len(z.Addr) + 6 + 1 + 9 + msgp.Int64Size + 10 + msgp.Int64Size + 9 + msgp.Int64Size + return +} + +// DecodeMsg implements msgp.Decodable +func (z *NodeStats) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "KeyCount": + z.KeyCount, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "KeyCount") + return + } + case "DiskBytes": + z.DiskBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "DiskBytes") + return + } + case "MemBytes": + z.MemBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "MemBytes") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z NodeStats) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "KeyCount" + err = en.Append(0x83, 0xa8, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74) + if err != nil { + return + } + err = en.WriteInt64(z.KeyCount) + if err != nil { + err = msgp.WrapError(err, "KeyCount") + return + } + // write "DiskBytes" + err = en.Append(0xa9, 0x44, 0x69, 0x73, 0x6b, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.DiskBytes) + if err != nil { + err = msgp.WrapError(err, "DiskBytes") + return + } + // write "MemBytes" + err = en.Append(0xa8, 0x4d, 0x65, 0x6d, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.MemBytes) + if err != nil { + err = msgp.WrapError(err, "MemBytes") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z NodeStats) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "KeyCount" + o = append(o, 0x83, 0xa8, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74) + o = msgp.AppendInt64(o, z.KeyCount) + // string "DiskBytes" + o = append(o, 0xa9, 0x44, 0x69, 0x73, 0x6b, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.DiskBytes) + // string "MemBytes" + o = append(o, 0xa8, 0x4d, 0x65, 0x6d, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.MemBytes) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *NodeStats) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "KeyCount": + z.KeyCount, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "KeyCount") + return + } + case "DiskBytes": + z.DiskBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "DiskBytes") + return + } + case "MemBytes": + z.MemBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "MemBytes") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z NodeStats) Msgsize() (s int) { + s = 1 + 9 + msgp.Int64Size + 10 + msgp.Int64Size + 9 + msgp.Int64Size + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedDeleteRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z ReplicatedDeleteRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Key" + err = en.Append(0x81, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z ReplicatedDeleteRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Key" + o = append(o, 0x81, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedDeleteRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z ReplicatedDeleteRequest) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedDeleteResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Deleted": + z.Deleted, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Deleted") + return + } + case "Error": + z.Error, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z ReplicatedDeleteResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "Success" + err = en.Append(0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + if err != nil { + return + } + err = en.WriteBool(z.Success) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + // write "Deleted" + err = en.Append(0xa7, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64) + if err != nil { + return + } + err = en.WriteBool(z.Deleted) + if err != nil { + err = msgp.WrapError(err, "Deleted") + return + } + // write "Error" + err = en.Append(0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Error) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z ReplicatedDeleteResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "Success" + o = append(o, 0x83, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + o = msgp.AppendBool(o, z.Success) + // string "Deleted" + o = append(o, 0xa7, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64) + o = msgp.AppendBool(o, z.Deleted) + // string "Error" + o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + o = msgp.AppendString(o, z.Error) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedDeleteResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Deleted": + z.Deleted, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Deleted") + return + } + case "Error": + z.Error, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z ReplicatedDeleteResponse) Msgsize() (s int) { + s = 1 + 8 + msgp.BoolSize + 8 + msgp.BoolSize + 6 + msgp.StringPrefixSize + len(z.Error) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedReadRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z ReplicatedReadRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 1 + // write "Key" + err = en.Append(0x81, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z ReplicatedReadRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 1 + // string "Key" + o = append(o, 0x81, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedReadRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z ReplicatedReadRequest) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedReadResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Found": + z.Found, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Tombstone": + z.Tombstone, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + case "Error": + z.Error, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *ReplicatedReadResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 4 + // write "Found" + err = en.Append(0x84, 0xa5, 0x46, 0x6f, 0x75, 0x6e, 0x64) + if err != nil { + return + } + err = en.WriteBool(z.Found) + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + // write "Tombstone" + err = en.Append(0xa9, 0x54, 0x6f, 0x6d, 0x62, 0x73, 0x74, 0x6f, 0x6e, 0x65) + if err != nil { + return + } + err = en.WriteBool(z.Tombstone) + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + // write "Error" + err = en.Append(0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Error) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *ReplicatedReadResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 4 + // string "Found" + o = append(o, 0x84, 0xa5, 0x46, 0x6f, 0x75, 0x6e, 0x64) + o = msgp.AppendBool(o, z.Found) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + // string "Tombstone" + o = append(o, 0xa9, 0x54, 0x6f, 0x6d, 0x62, 0x73, 0x74, 0x6f, 0x6e, 0x65) + o = msgp.AppendBool(o, z.Tombstone) + // string "Error" + o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + o = msgp.AppendString(o, z.Error) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedReadResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Found": + z.Found, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Found") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Tombstone": + z.Tombstone, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Tombstone") + return + } + case "Error": + z.Error, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *ReplicatedReadResponse) Msgsize() (s int) { + s = 1 + 6 + msgp.BoolSize + 6 + msgp.BytesPrefixSize + len(z.Value) + 10 + msgp.BoolSize + 6 + msgp.StringPrefixSize + len(z.Error) + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedWriteRequest) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "VectorClock": + var zb0002 uint32 + zb0002, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + if z.VectorClock == nil { + z.VectorClock = make(map[string]uint64, zb0002) + } else if len(z.VectorClock) > 0 { + clear(z.VectorClock) + } + for zb0002 > 0 { + zb0002-- + var za0001 string + za0001, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + var za0002 uint64 + za0002, err = dc.ReadUint64() + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + z.VectorClock[za0001] = za0002 + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *ReplicatedWriteRequest) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "Key" + err = en.Append(0x83, 0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + // write "VectorClock" + err = en.Append(0xab, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x6f, 0x63, 0x6b) + if err != nil { + return + } + err = en.WriteMapHeader(uint32(len(z.VectorClock))) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + for za0001, za0002 := range z.VectorClock { + err = en.WriteString(za0001) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + err = en.WriteUint64(za0002) + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *ReplicatedWriteRequest) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "Key" + o = append(o, 0x83, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + // string "VectorClock" + o = append(o, 0xab, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x6f, 0x63, 0x6b) + o = msgp.AppendMapHeader(o, uint32(len(z.VectorClock))) + for za0001, za0002 := range z.VectorClock { + o = msgp.AppendString(o, za0001) + o = msgp.AppendUint64(o, za0002) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedWriteRequest) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "VectorClock": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + if z.VectorClock == nil { + z.VectorClock = make(map[string]uint64, zb0002) + } else if len(z.VectorClock) > 0 { + clear(z.VectorClock) + } + for zb0002 > 0 { + var za0002 uint64 + zb0002-- + var za0001 string + za0001, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + za0002, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + z.VectorClock[za0001] = za0002 + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *ReplicatedWriteRequest) Msgsize() (s int) { + s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.BytesPrefixSize + len(z.Value) + 12 + msgp.MapHeaderSize + if z.VectorClock != nil { + for za0001, za0002 := range z.VectorClock { + _ = za0002 + s += msgp.StringPrefixSize + len(za0001) + msgp.Uint64Size + } + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *ReplicatedWriteResponse) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, err = dc.ReadBool() + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Error": + z.Error, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z ReplicatedWriteResponse) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 2 + // write "Success" + err = en.Append(0x82, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + if err != nil { + return + } + err = en.WriteBool(z.Success) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + // write "Error" + err = en.Append(0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + if err != nil { + return + } + err = en.WriteString(z.Error) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z ReplicatedWriteResponse) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 2 + // string "Success" + o = append(o, 0x82, 0xa7, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73) + o = msgp.AppendBool(o, z.Success) + // string "Error" + o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72) + o = msgp.AppendString(o, z.Error) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *ReplicatedWriteResponse) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Success": + z.Success, bts, err = msgp.ReadBoolBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Success") + return + } + case "Error": + z.Error, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Error") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z ReplicatedWriteResponse) Msgsize() (s int) { + s = 1 + 8 + msgp.BoolSize + 6 + msgp.StringPrefixSize + len(z.Error) + return +} diff --git a/internal/store/lsm-engine/sstable.go b/internal/store/lsm-engine/sstable.go index fd3e357..f301619 100644 --- a/internal/store/lsm-engine/sstable.go +++ b/internal/store/lsm-engine/sstable.go @@ -13,14 +13,38 @@ import ( storage "github.com/DevLikhith5/kasoku/internal/store" "github.com/golang/snappy" + "github.com/klauspost/compress/zstd" ) const ( DefaultBlockSize = 64 * 1024 // 64KB blocks (optimized for SSD sequential I/O) MaxBlockSize = 256 * 1024 // 256KB max block size BinaryEncodingMode = true // BINARY ONLY - for maximum performance + UseZstdCompression = true // Use zstd instead of snappy (faster decompression) ) +var ( + zstdEncoder *zstd.Encoder + zstdDecoder *zstd.Decoder +) + +func init() { + if UseZstdCompression { + enc, err := zstd.NewWriter(nil, zstd.WithEncoderLevel(zstd.SpeedFastest)) + if err == nil { + zstdEncoder = enc + } + dec, err := zstd.NewReader(nil) + if err == nil { + zstdDecoder = dec + } + } +} + +func decodeZstd(data []byte) ([]byte, error) { + return zstdDecoder.DecodeAll(data, nil) +} + type indexEntry struct { Key string `json:"k"` Offset int64 `json:"o"` @@ -292,7 +316,12 @@ func (w *SSTableWriter) WriteEntry(entry storage.Entry) error { // Compress data block if w.compress { - compressedData := snappy.Encode(nil, data) + var compressedData []byte + if UseZstdCompression && zstdEncoder != nil { + compressedData = zstdEncoder.EncodeAll(data, nil) + } else { + compressedData = snappy.Encode(nil, data) + } // Only use compression if it actually saves space if len(compressedData) < len(data) { finalData = compressedData @@ -563,11 +592,19 @@ func (r *SSTableReader) getAtIndex(idx int) (storage.Entry, error) { // Decompress if needed if entry.Compressed { - decompressed, err := snappy.Decode(nil, data[4:]) - if err != nil { - return storage.Entry{}, err + if UseZstdCompression && zstdDecoder != nil { + decompressed, decErr := decodeZstd(data[4:]) + if decErr != nil { + return storage.Entry{}, decErr + } + data = decompressed + } else { + decompressed, decErr := snappy.Decode(nil, data[4:]) + if decErr != nil { + return storage.Entry{}, decErr + } + data = decompressed } - data = decompressed } else { data = data[4:] } @@ -659,11 +696,19 @@ func (r *SSTableReader) Scan(prefix string) ([]storage.Entry, error) { var s storage.Entry blockData := data[4:] // skip length prefix if entry.Compressed { - decompressed, err := snappy.Decode(nil, blockData) - if err != nil { - continue + if UseZstdCompression && zstdDecoder != nil { + decompressed, decErr := decodeZstd(blockData) + if decErr != nil { + continue + } + blockData = decompressed + } else { + decompressed, decErr := snappy.Decode(nil, blockData) + if decErr != nil { + continue + } + blockData = decompressed } - blockData = decompressed // After decompression, data starts directly with magic byte } diff --git a/internal/store/pools.go b/internal/store/pools.go new file mode 100644 index 0000000..fbeaea8 --- /dev/null +++ b/internal/store/pools.go @@ -0,0 +1,88 @@ +package storage + +import ( + "sync" + "time" +) + +var ( + entryPool = sync.Pool{ + New: func() interface{} { + return &Entry{} + }, + } + + entrySlicePool = sync.Pool{ + New: func() interface{} { + return make([]Entry, 0, 64) + }, + } + + resultMapPool = sync.Pool{ + New: func() interface{} { + return make(map[string]Entry) + }, + } + + bytesBufferPool = sync.Pool{ + New: func() interface{} { + return make([]byte, 0, 4096) + }, + } +) + +func GetEntry() *Entry { + return entryPool.Get().(*Entry) +} + +func PutEntry(e *Entry) { + if e == nil { + return + } + e.Key = "" + e.Value = nil + e.Version = 0 + e.TimeStamp = time.Time{} + e.Tombstone = false + e.VectorClock = nil + entryPool.Put(e) +} + +func GetEntrySlice() []Entry { + return entrySlicePool.Get().([]Entry) +} + +func PutEntrySlice(s []Entry) { + if s == nil { + return + } + for i := range s { + s[i] = Entry{} + } + entrySlicePool.Put(s[:0]) +} + +func GetResultMap() map[string]Entry { + return resultMapPool.Get().(map[string]Entry) +} + +func PutResultMap(m map[string]Entry) { + if m == nil { + return + } + for k := range m { + delete(m, k) + } + resultMapPool.Put(m) +} + +func GetBytesBuffer() []byte { + return bytesBufferPool.Get().([]byte) +} + +func PutBytesBuffer(b []byte) { + if b == nil { + return + } + bytesBufferPool.Put(b[:0]) +} diff --git a/internal/store/wal_gen.go b/internal/store/wal_gen.go new file mode 100644 index 0000000..44fee88 --- /dev/null +++ b/internal/store/wal_gen.go @@ -0,0 +1,624 @@ +// Code generated by github.com/tinylib/msgp DO NOT EDIT. + +package storage + +import ( + "github.com/tinylib/msgp/msgp" +) + +// DecodeMsg implements msgp.Decodable +func (z *WAL) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z WAL) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 0 + _ = z + err = en.Append(0x80) + if err != nil { + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z WAL) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 0 + _ = z + o = append(o, 0x80) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *WAL) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z WAL) Msgsize() (s int) { + s = 1 + return +} + +// DecodeMsg implements msgp.Decodable +func (z *WALConfig) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "SyncInterval": + z.SyncInterval, err = dc.ReadDuration() + if err != nil { + err = msgp.WrapError(err, "SyncInterval") + return + } + case "CheckpointBytes": + z.CheckpointBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "CheckpointBytes") + return + } + case "MaxBufferedBytes": + z.MaxBufferedBytes, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "MaxBufferedBytes") + return + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z WALConfig) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 3 + // write "SyncInterval" + err = en.Append(0x83, 0xac, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c) + if err != nil { + return + } + err = en.WriteDuration(z.SyncInterval) + if err != nil { + err = msgp.WrapError(err, "SyncInterval") + return + } + // write "CheckpointBytes" + err = en.Append(0xaf, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.CheckpointBytes) + if err != nil { + err = msgp.WrapError(err, "CheckpointBytes") + return + } + // write "MaxBufferedBytes" + err = en.Append(0xb0, 0x4d, 0x61, 0x78, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73) + if err != nil { + return + } + err = en.WriteInt64(z.MaxBufferedBytes) + if err != nil { + err = msgp.WrapError(err, "MaxBufferedBytes") + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z WALConfig) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 3 + // string "SyncInterval" + o = append(o, 0x83, 0xac, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c) + o = msgp.AppendDuration(o, z.SyncInterval) + // string "CheckpointBytes" + o = append(o, 0xaf, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.CheckpointBytes) + // string "MaxBufferedBytes" + o = append(o, 0xb0, 0x4d, 0x61, 0x78, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73) + o = msgp.AppendInt64(o, z.MaxBufferedBytes) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *WALConfig) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "SyncInterval": + z.SyncInterval, bts, err = msgp.ReadDurationBytes(bts) + if err != nil { + err = msgp.WrapError(err, "SyncInterval") + return + } + case "CheckpointBytes": + z.CheckpointBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "CheckpointBytes") + return + } + case "MaxBufferedBytes": + z.MaxBufferedBytes, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "MaxBufferedBytes") + return + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z WALConfig) Msgsize() (s int) { + s = 1 + 13 + msgp.DurationSize + 16 + msgp.Int64Size + 17 + msgp.Int64Size + return +} + +// DecodeMsg implements msgp.Decodable +func (z *WALRecord) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Op": + z.Op, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Op") + return + } + case "Key": + z.Key, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, err = dc.ReadBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Version": + z.Version, err = dc.ReadUint64() + if err != nil { + err = msgp.WrapError(err, "Version") + return + } + case "TimeStamp": + z.TimeStamp, err = dc.ReadInt64() + if err != nil { + err = msgp.WrapError(err, "TimeStamp") + return + } + case "VectorClock": + var zb0002 uint32 + zb0002, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + if z.VectorClock == nil { + z.VectorClock = make(map[string]uint64, zb0002) + } else if len(z.VectorClock) > 0 { + clear(z.VectorClock) + } + for zb0002 > 0 { + zb0002-- + var za0001 string + za0001, err = dc.ReadString() + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + var za0002 uint64 + za0002, err = dc.ReadUint64() + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + z.VectorClock[za0001] = za0002 + } + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z *WALRecord) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 6 + // write "Op" + err = en.Append(0x86, 0xa2, 0x4f, 0x70) + if err != nil { + return + } + err = en.WriteString(z.Op) + if err != nil { + err = msgp.WrapError(err, "Op") + return + } + // write "Key" + err = en.Append(0xa3, 0x4b, 0x65, 0x79) + if err != nil { + return + } + err = en.WriteString(z.Key) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + // write "Value" + err = en.Append(0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + if err != nil { + return + } + err = en.WriteBytes(z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + // write "Version" + err = en.Append(0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e) + if err != nil { + return + } + err = en.WriteUint64(z.Version) + if err != nil { + err = msgp.WrapError(err, "Version") + return + } + // write "TimeStamp" + err = en.Append(0xa9, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70) + if err != nil { + return + } + err = en.WriteInt64(z.TimeStamp) + if err != nil { + err = msgp.WrapError(err, "TimeStamp") + return + } + // write "VectorClock" + err = en.Append(0xab, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x6f, 0x63, 0x6b) + if err != nil { + return + } + err = en.WriteMapHeader(uint32(len(z.VectorClock))) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + for za0001, za0002 := range z.VectorClock { + err = en.WriteString(za0001) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + err = en.WriteUint64(za0002) + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z *WALRecord) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 6 + // string "Op" + o = append(o, 0x86, 0xa2, 0x4f, 0x70) + o = msgp.AppendString(o, z.Op) + // string "Key" + o = append(o, 0xa3, 0x4b, 0x65, 0x79) + o = msgp.AppendString(o, z.Key) + // string "Value" + o = append(o, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65) + o = msgp.AppendBytes(o, z.Value) + // string "Version" + o = append(o, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e) + o = msgp.AppendUint64(o, z.Version) + // string "TimeStamp" + o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70) + o = msgp.AppendInt64(o, z.TimeStamp) + // string "VectorClock" + o = append(o, 0xab, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x6f, 0x63, 0x6b) + o = msgp.AppendMapHeader(o, uint32(len(z.VectorClock))) + for za0001, za0002 := range z.VectorClock { + o = msgp.AppendString(o, za0001) + o = msgp.AppendUint64(o, za0002) + } + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *WALRecord) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + case "Op": + z.Op, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Op") + return + } + case "Key": + z.Key, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "Key") + return + } + case "Value": + z.Value, bts, err = msgp.ReadBytesBytes(bts, z.Value) + if err != nil { + err = msgp.WrapError(err, "Value") + return + } + case "Version": + z.Version, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "Version") + return + } + case "TimeStamp": + z.TimeStamp, bts, err = msgp.ReadInt64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "TimeStamp") + return + } + case "VectorClock": + var zb0002 uint32 + zb0002, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + if z.VectorClock == nil { + z.VectorClock = make(map[string]uint64, zb0002) + } else if len(z.VectorClock) > 0 { + clear(z.VectorClock) + } + for zb0002 > 0 { + var za0002 uint64 + zb0002-- + var za0001 string + za0001, bts, err = msgp.ReadStringBytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock") + return + } + za0002, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "VectorClock", za0001) + return + } + z.VectorClock[za0001] = za0002 + } + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z *WALRecord) Msgsize() (s int) { + s = 1 + 3 + msgp.StringPrefixSize + len(z.Op) + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.BytesPrefixSize + len(z.Value) + 8 + msgp.Uint64Size + 10 + msgp.Int64Size + 12 + msgp.MapHeaderSize + if z.VectorClock != nil { + for za0001, za0002 := range z.VectorClock { + _ = za0002 + s += msgp.StringPrefixSize + len(za0001) + msgp.Uint64Size + } + } + return +} + +// DecodeMsg implements msgp.Decodable +func (z *WALReplayHandlerFuncs) DecodeMsg(dc *msgp.Reader) (err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, err = dc.ReadMapHeader() + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, err = dc.ReadMapKeyPtr() + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + err = dc.Skip() + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + return +} + +// EncodeMsg implements msgp.Encodable +func (z WALReplayHandlerFuncs) EncodeMsg(en *msgp.Writer) (err error) { + // map header, size 0 + _ = z + err = en.Append(0x80) + if err != nil { + return + } + return +} + +// MarshalMsg implements msgp.Marshaler +func (z WALReplayHandlerFuncs) MarshalMsg(b []byte) (o []byte, err error) { + o = msgp.Require(b, z.Msgsize()) + // map header, size 0 + _ = z + o = append(o, 0x80) + return +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *WALReplayHandlerFuncs) UnmarshalMsg(bts []byte) (o []byte, err error) { + var field []byte + _ = field + var zb0001 uint32 + zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + for zb0001 > 0 { + zb0001-- + field, bts, err = msgp.ReadMapKeyZC(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + switch msgp.UnsafeString(field) { + default: + bts, err = msgp.Skip(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + } + } + o = bts + return +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z WALReplayHandlerFuncs) Msgsize() (s int) { + s = 1 + return +} diff --git a/internal/store/wal_gen_test.go b/internal/store/wal_gen_test.go new file mode 100644 index 0000000..7eb04c8 --- /dev/null +++ b/internal/store/wal_gen_test.go @@ -0,0 +1,462 @@ +// Code generated by github.com/tinylib/msgp DO NOT EDIT. + +package storage + +import ( + "bytes" + "testing" + + "github.com/tinylib/msgp/msgp" +) + +func TestMarshalUnmarshalWAL(t *testing.T) { + v := WAL{} + bts, err := v.MarshalMsg(nil) + if err != nil { + t.Fatal(err) + } + left, err := v.UnmarshalMsg(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) + } + + left, err = msgp.Skip(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after Skip(): %q", len(left), left) + } +} + +func BenchmarkMarshalMsgWAL(b *testing.B) { + v := WAL{} + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.MarshalMsg(nil) + } +} + +func BenchmarkAppendMsgWAL(b *testing.B) { + v := WAL{} + bts := make([]byte, 0, v.Msgsize()) + bts, _ = v.MarshalMsg(bts[0:0]) + b.SetBytes(int64(len(bts))) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + bts, _ = v.MarshalMsg(bts[0:0]) + } +} + +func BenchmarkUnmarshalWAL(b *testing.B) { + v := WAL{} + bts, _ := v.MarshalMsg(nil) + b.ReportAllocs() + b.SetBytes(int64(len(bts))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := v.UnmarshalMsg(bts) + if err != nil { + b.Fatal(err) + } + } +} + +func TestEncodeDecodeWAL(t *testing.T) { + v := WAL{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + + m := v.Msgsize() + if buf.Len() > m { + t.Log("WARNING: TestEncodeDecodeWAL Msgsize() is inaccurate") + } + + vn := WAL{} + err := msgp.Decode(&buf, &vn) + if err != nil { + t.Error(err) + } + + buf.Reset() + msgp.Encode(&buf, &v) + err = msgp.NewReader(&buf).Skip() + if err != nil { + t.Error(err) + } +} + +func BenchmarkEncodeWAL(b *testing.B) { + v := WAL{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + en := msgp.NewWriter(msgp.Nowhere) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.EncodeMsg(en) + } + en.Flush() +} + +func BenchmarkDecodeWAL(b *testing.B) { + v := WAL{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + rd := msgp.NewEndlessReader(buf.Bytes(), b) + dc := msgp.NewReader(rd) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + err := v.DecodeMsg(dc) + if err != nil { + b.Fatal(err) + } + } +} + +func TestMarshalUnmarshalWALConfig(t *testing.T) { + v := WALConfig{} + bts, err := v.MarshalMsg(nil) + if err != nil { + t.Fatal(err) + } + left, err := v.UnmarshalMsg(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) + } + + left, err = msgp.Skip(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after Skip(): %q", len(left), left) + } +} + +func BenchmarkMarshalMsgWALConfig(b *testing.B) { + v := WALConfig{} + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.MarshalMsg(nil) + } +} + +func BenchmarkAppendMsgWALConfig(b *testing.B) { + v := WALConfig{} + bts := make([]byte, 0, v.Msgsize()) + bts, _ = v.MarshalMsg(bts[0:0]) + b.SetBytes(int64(len(bts))) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + bts, _ = v.MarshalMsg(bts[0:0]) + } +} + +func BenchmarkUnmarshalWALConfig(b *testing.B) { + v := WALConfig{} + bts, _ := v.MarshalMsg(nil) + b.ReportAllocs() + b.SetBytes(int64(len(bts))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := v.UnmarshalMsg(bts) + if err != nil { + b.Fatal(err) + } + } +} + +func TestEncodeDecodeWALConfig(t *testing.T) { + v := WALConfig{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + + m := v.Msgsize() + if buf.Len() > m { + t.Log("WARNING: TestEncodeDecodeWALConfig Msgsize() is inaccurate") + } + + vn := WALConfig{} + err := msgp.Decode(&buf, &vn) + if err != nil { + t.Error(err) + } + + buf.Reset() + msgp.Encode(&buf, &v) + err = msgp.NewReader(&buf).Skip() + if err != nil { + t.Error(err) + } +} + +func BenchmarkEncodeWALConfig(b *testing.B) { + v := WALConfig{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + en := msgp.NewWriter(msgp.Nowhere) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.EncodeMsg(en) + } + en.Flush() +} + +func BenchmarkDecodeWALConfig(b *testing.B) { + v := WALConfig{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + rd := msgp.NewEndlessReader(buf.Bytes(), b) + dc := msgp.NewReader(rd) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + err := v.DecodeMsg(dc) + if err != nil { + b.Fatal(err) + } + } +} + +func TestMarshalUnmarshalWALRecord(t *testing.T) { + v := WALRecord{} + bts, err := v.MarshalMsg(nil) + if err != nil { + t.Fatal(err) + } + left, err := v.UnmarshalMsg(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) + } + + left, err = msgp.Skip(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after Skip(): %q", len(left), left) + } +} + +func BenchmarkMarshalMsgWALRecord(b *testing.B) { + v := WALRecord{} + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.MarshalMsg(nil) + } +} + +func BenchmarkAppendMsgWALRecord(b *testing.B) { + v := WALRecord{} + bts := make([]byte, 0, v.Msgsize()) + bts, _ = v.MarshalMsg(bts[0:0]) + b.SetBytes(int64(len(bts))) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + bts, _ = v.MarshalMsg(bts[0:0]) + } +} + +func BenchmarkUnmarshalWALRecord(b *testing.B) { + v := WALRecord{} + bts, _ := v.MarshalMsg(nil) + b.ReportAllocs() + b.SetBytes(int64(len(bts))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := v.UnmarshalMsg(bts) + if err != nil { + b.Fatal(err) + } + } +} + +func TestEncodeDecodeWALRecord(t *testing.T) { + v := WALRecord{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + + m := v.Msgsize() + if buf.Len() > m { + t.Log("WARNING: TestEncodeDecodeWALRecord Msgsize() is inaccurate") + } + + vn := WALRecord{} + err := msgp.Decode(&buf, &vn) + if err != nil { + t.Error(err) + } + + buf.Reset() + msgp.Encode(&buf, &v) + err = msgp.NewReader(&buf).Skip() + if err != nil { + t.Error(err) + } +} + +func BenchmarkEncodeWALRecord(b *testing.B) { + v := WALRecord{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + en := msgp.NewWriter(msgp.Nowhere) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.EncodeMsg(en) + } + en.Flush() +} + +func BenchmarkDecodeWALRecord(b *testing.B) { + v := WALRecord{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + rd := msgp.NewEndlessReader(buf.Bytes(), b) + dc := msgp.NewReader(rd) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + err := v.DecodeMsg(dc) + if err != nil { + b.Fatal(err) + } + } +} + +func TestMarshalUnmarshalWALReplayHandlerFuncs(t *testing.T) { + v := WALReplayHandlerFuncs{} + bts, err := v.MarshalMsg(nil) + if err != nil { + t.Fatal(err) + } + left, err := v.UnmarshalMsg(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) + } + + left, err = msgp.Skip(bts) + if err != nil { + t.Fatal(err) + } + if len(left) > 0 { + t.Errorf("%d bytes left over after Skip(): %q", len(left), left) + } +} + +func BenchmarkMarshalMsgWALReplayHandlerFuncs(b *testing.B) { + v := WALReplayHandlerFuncs{} + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.MarshalMsg(nil) + } +} + +func BenchmarkAppendMsgWALReplayHandlerFuncs(b *testing.B) { + v := WALReplayHandlerFuncs{} + bts := make([]byte, 0, v.Msgsize()) + bts, _ = v.MarshalMsg(bts[0:0]) + b.SetBytes(int64(len(bts))) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + bts, _ = v.MarshalMsg(bts[0:0]) + } +} + +func BenchmarkUnmarshalWALReplayHandlerFuncs(b *testing.B) { + v := WALReplayHandlerFuncs{} + bts, _ := v.MarshalMsg(nil) + b.ReportAllocs() + b.SetBytes(int64(len(bts))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := v.UnmarshalMsg(bts) + if err != nil { + b.Fatal(err) + } + } +} + +func TestEncodeDecodeWALReplayHandlerFuncs(t *testing.T) { + v := WALReplayHandlerFuncs{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + + m := v.Msgsize() + if buf.Len() > m { + t.Log("WARNING: TestEncodeDecodeWALReplayHandlerFuncs Msgsize() is inaccurate") + } + + vn := WALReplayHandlerFuncs{} + err := msgp.Decode(&buf, &vn) + if err != nil { + t.Error(err) + } + + buf.Reset() + msgp.Encode(&buf, &v) + err = msgp.NewReader(&buf).Skip() + if err != nil { + t.Error(err) + } +} + +func BenchmarkEncodeWALReplayHandlerFuncs(b *testing.B) { + v := WALReplayHandlerFuncs{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + en := msgp.NewWriter(msgp.Nowhere) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + v.EncodeMsg(en) + } + en.Flush() +} + +func BenchmarkDecodeWALReplayHandlerFuncs(b *testing.B) { + v := WALReplayHandlerFuncs{} + var buf bytes.Buffer + msgp.Encode(&buf, &v) + b.SetBytes(int64(buf.Len())) + rd := msgp.NewEndlessReader(buf.Bytes(), b) + dc := msgp.NewReader(rd) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + err := v.DecodeMsg(dc) + if err != nil { + b.Fatal(err) + } + } +}