proto: Update 'Compression' to int to support different compression algorithms

With nexedi/neoppod@fd80cc30 NEO/py added support to encode the compression
algorithm with the 'Compression' parameter. Before this, compression could
only be true (= with compression) or false (= without compression). Now
the absence of compression is encoded with 0. Any other number than 0
encodes a compression algorithm. The mapping is currently:

	1 = zlib

In the future, 2 could mean zstd [1].

[1] https://github.com/facebook/zstd/issues/1134

go/neo/client.go

@@ -381,7 +381,10 @@ func (c *Client) Load(ctx context.Context, xid zodb.Xid) (buf *mem.Buf, serial z
 		}
 	}
 
-	if resp.Compression {
+	if resp.Compression != 0 {
+		if resp.Compression != 1 {
+			return nil, 0, fmt.Errorf("unsupported compression algorithm: %v", resp.Compression)
+		}
 		buf2 := &mem.Buf{Data: nil}
 		udata, err := xzlib.Decompress(buf.Data)
 		buf.Release()

go/neo/neo_test.go

@@ -257,7 +257,7 @@ func _TestMasterStorage(t0 *tEnv) {
 		Oid:		xid1.Oid,
 		Serial:		serial1,
 		NextSerial:	proto.INVALID_TID,
-		Compression:	false,
+		Compression:	0,
 		Data:		buf1,
 		DataSerial:	0,		// XXX
 		Checksum:	sha1.Sum(buf1.Data),
@@ -292,7 +292,7 @@ func _TestMasterStorage(t0 *tEnv) {
 		Oid:		xid1prev.Oid,
 		Serial:		serial1prev,
 		NextSerial:	serial1,
-		Compression:	false,
+		Compression:	0,
 		Data:		buf1prev,
 		DataSerial:	0,		// XXX
 		Checksum:	sha1.Sum(buf1prev.Data),

go/neo/proto/proto.go

@@ -336,6 +336,11 @@ func (a *Address) neoDecodeN(b []byte) (uint64, bool) {
 // Checksum is a SHA1 hash.
 type Checksum [20]byte
 
+// Compression is an integer that tells the compression algorithm:
+//	0 = no compression algorithm is used
+//	1 = zlib is used
+type Compression uint64
+
 // PTid is Partition Table identifier.
 //
 // Zero value means "invalid id" (<-> None in py.PPTID, nil in msgpack)
@@ -713,7 +718,7 @@ type AnswerRebaseObject struct {
 	Serial         zodb.Tid
 	ConflictSerial zodb.Tid
 	// FIXME POption('data')
-		Compression bool
+		Compression Compression
 		Checksum    Checksum
 		Data        *mem.Buf
 }
@@ -727,7 +732,7 @@ type AnswerRebaseObject struct {
 type StoreObject struct {
 	Oid         zodb.Oid
 	Serial      zodb.Tid
-	Compression bool
+	Compression Compression
 	Checksum    Checksum
 	Data        []byte // TODO -> msg.Buf, separately (for writev)
 	DataSerial  zodb.Tid
@@ -782,7 +787,7 @@ type AnswerObject struct {
 	Oid         zodb.Oid
 	Serial      zodb.Tid
 	NextSerial  zodb.Tid
-	Compression bool
+	Compression Compression
 	Checksum    Checksum
 	Data        *mem.Buf // TODO encode -> separately (for writev)
 	DataSerial  zodb.Tid
@@ -1217,7 +1222,7 @@ type AddTransaction struct {
 type AddObject struct {
 	Oid         zodb.Oid
 	Serial      zodb.Tid
-	Compression bool
+	Compression Compression
 	Checksum    Checksum
 	Data        *mem.Buf
 	DataSerial  zodb.Tid

go/neo/proto/zproto-marshal.go

@@ -4965,18 +4965,18 @@ func (*AnswerRebaseObject) neoMsgCode() uint16 {
 }
 
 func (p *AnswerRebaseObject) neoMsgEncodedLenN() int {
-	return 41 + len(p.Data.XData())
+	return 48 + len(p.Data.XData())
 }
 
 func (p *AnswerRebaseObject) neoMsgEncodeN(data []byte) {
 	binary.BigEndian.PutUint64(data[0:], uint64(p.Serial))
 	binary.BigEndian.PutUint64(data[8:], uint64(p.ConflictSerial))
-	(data[16:])[0] = bool2byte(p.Compression)
-	copy(data[17:], p.Checksum[:])
+	binary.BigEndian.PutUint64(data[16:], uint64(p.Compression))
+	copy(data[24:], p.Checksum[:])
 	{
 		l := uint32(len(p.Data.XData()))
-		binary.BigEndian.PutUint32(data[37:], l)
-		data = data[41:]
+		binary.BigEndian.PutUint32(data[44:], l)
+		data = data[48:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -4984,16 +4984,16 @@ func (p *AnswerRebaseObject) neoMsgEncodeN(data []byte) {
 
 func (p *AnswerRebaseObject) neoMsgDecodeN(data []byte) (int, error) {
 	var nread uint64
-	if len(data) < 41 {
+	if len(data) < 48 {
 		goto overflow
 	}
 	p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[0 : 0+8]))
 	p.ConflictSerial = zodb.Tid(binary.BigEndian.Uint64(data[8 : 8+8]))
-	p.Compression = byte2bool((data[16 : 16+1])[0])
-	copy(p.Checksum[:], data[17:37])
+	p.Compression = Compression(binary.BigEndian.Uint64(data[16 : 16+8]))
+	copy(p.Checksum[:], data[24:44])
 	{
-		l := binary.BigEndian.Uint32(data[37 : 37+4])
-		data = data[41:]
+		l := binary.BigEndian.Uint32(data[44 : 44+4])
+		data = data[48:]
 		if uint64(len(data)) < uint64(l) {
 			goto overflow
 		}
@@ -5002,7 +5002,7 @@ func (p *AnswerRebaseObject) neoMsgDecodeN(data []byte) (int, error) {
 		copy(p.Data.Data, data[:l])
 		data = data[l:]
 	}
-	return 41 + int(nread), nil
+	return 48 + int(nread), nil
 
 overflow:
 	return 0, ErrDecodeOverflow
@@ -5020,7 +5020,7 @@ func (p *AnswerRebaseObject) neoMsgEncodedLenM() int {
 	} else {
 		size += 1 + 1 + 8 // mbin8 + 8 + [8]data
 	}
-	return 24 + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
+	return 23 + msgpack.Uint64Size(uint64(p.Compression)) + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
 }
 
 func (p *AnswerRebaseObject) neoMsgEncodeM(data []byte) {
@@ -5043,14 +5043,17 @@ func (p *AnswerRebaseObject) neoMsgEncodeM(data []byte) {
 		binary.BigEndian.PutUint64(data[2:], uint64(p.ConflictSerial))
 		data = data[10:]
 	}
-	data[0] = byte(msgpack.Bool(p.Compression))
-	data[1] = byte(msgpack.Bin8)
-	data[2] = 20
-	copy(data[3:], p.Checksum[:])
+	{
+		n := msgpack.PutUint64(data[0:], uint64(p.Compression))
+		data = data[0+n:]
+	}
+	data[0] = byte(msgpack.Bin8)
+	data[1] = 20
+	copy(data[2:], p.Checksum[:])
 	{
 		l := len(p.Data.XData())
-		n := msgpack.PutBinHead(data[23:], l)
-		data = data[23+n:]
+		n := msgpack.PutBinHead(data[22:], l)
+		data = data[22+n:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -5103,25 +5106,26 @@ func (p *AnswerRebaseObject) neoMsgDecodeM(data []byte) (int, error) {
 		p.ConflictSerial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
 		data = data[10:]
 	}
-	if len(data) < 23 {
-		goto overflow
+	{
+		v, tail, err := msgp.ReadUint64Bytes(data)
+		if err != nil {
+			return 0, mdecodeErr("AnswerRebaseObject.Compression", err)
+		}
+		p.Compression = Compression(v)
+		nread += uint64(len(data) - len(tail))
+		data = tail
 	}
-	switch op := msgpack.Op(data[0]); op {
-	default:
-		return 0, mdecodeOpErr("AnswerRebaseObject.Compression", op, msgpack.True, msgpack.False)
-	case msgpack.True:
-		p.Compression = true
-	case msgpack.False:
-		p.Compression = false
+	if len(data) < 22 {
+		goto overflow
 	}
-	if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
+	if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
 		return 0, mdecodeOpErr("AnswerRebaseObject.Checksum", op, msgpack.Bin8)
 	}
-	if l := data[2]; l != 20 {
+	if l := data[1]; l != 20 {
 		return 0, mdecodeLen8Err("AnswerRebaseObject.Checksum", l, 20)
 	}
-	copy(p.Checksum[:], data[3:23])
-	data = data[23:]
+	copy(p.Checksum[:], data[2:22])
+	data = data[22:]
 	{
 		b, tail, err := msgp.ReadBytesZC(data)
 		if err != nil {
@@ -5145,18 +5149,18 @@ func (*StoreObject) neoMsgCode() uint16 {
 }
 
 func (p *StoreObject) neoMsgEncodedLenN() int {
-	return 57 + len(p.Data)
+	return 64 + len(p.Data)
 }
 
 func (p *StoreObject) neoMsgEncodeN(data []byte) {
 	binary.BigEndian.PutUint64(data[0:], uint64(p.Oid))
 	binary.BigEndian.PutUint64(data[8:], uint64(p.Serial))
-	(data[16:])[0] = bool2byte(p.Compression)
-	copy(data[17:], p.Checksum[:])
+	binary.BigEndian.PutUint64(data[16:], uint64(p.Compression))
+	copy(data[24:], p.Checksum[:])
 	{
 		l := uint32(len(p.Data))
-		binary.BigEndian.PutUint32(data[37:], l)
-		data = data[41:]
+		binary.BigEndian.PutUint32(data[44:], l)
+		data = data[48:]
 		copy(data, p.Data)
 		data = data[l:]
 	}
@@ -5166,16 +5170,16 @@ func (p *StoreObject) neoMsgEncodeN(data []byte) {
 
 func (p *StoreObject) neoMsgDecodeN(data []byte) (int, error) {
 	var nread uint64
-	if len(data) < 41 {
+	if len(data) < 48 {
 		goto overflow
 	}
 	p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[0 : 0+8]))
 	p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[8 : 8+8]))
-	p.Compression = byte2bool((data[16 : 16+1])[0])
-	copy(p.Checksum[:], data[17:37])
+	p.Compression = Compression(binary.BigEndian.Uint64(data[16 : 16+8]))
+	copy(p.Checksum[:], data[24:44])
 	{
-		l := binary.BigEndian.Uint32(data[37 : 37+4])
-		data = data[41:]
+		l := binary.BigEndian.Uint32(data[44 : 44+4])
+		data = data[48:]
 		if uint64(len(data)) < 16+uint64(l) {
 			goto overflow
 		}
@@ -5186,7 +5190,7 @@ func (p *StoreObject) neoMsgDecodeN(data []byte) (int, error) {
 	}
 	p.DataSerial = zodb.Tid(binary.BigEndian.Uint64(data[0 : 0+8]))
 	p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[8 : 8+8]))
-	return 41 + int(nread), nil
+	return 48 + int(nread), nil
 
 overflow:
 	return 0, ErrDecodeOverflow
@@ -5214,7 +5218,7 @@ func (p *StoreObject) neoMsgEncodedLenM() int {
 	} else {
 		size += 1 + 1 + 8 // mbin8 + 8 + [8]data
 	}
-	return 24 + msgpack.BinHeadSize(len(p.Data)) + len(p.Data) + size
+	return 23 + msgpack.Uint64Size(uint64(p.Compression)) + msgpack.BinHeadSize(len(p.Data)) + len(p.Data) + size
 }
 
 func (p *StoreObject) neoMsgEncodeM(data []byte) {
@@ -5237,14 +5241,17 @@ func (p *StoreObject) neoMsgEncodeM(data []byte) {
 		binary.BigEndian.PutUint64(data[2:], uint64(p.Serial))
 		data = data[10:]
 	}
-	data[0] = byte(msgpack.Bool(p.Compression))
-	data[1] = byte(msgpack.Bin8)
-	data[2] = 20
-	copy(data[3:], p.Checksum[:])
+	{
+		n := msgpack.PutUint64(data[0:], uint64(p.Compression))
+		data = data[0+n:]
+	}
+	data[0] = byte(msgpack.Bin8)
+	data[1] = 20
+	copy(data[2:], p.Checksum[:])
 	{
 		l := len(p.Data)
-		n := msgpack.PutBinHead(data[23:], l)
-		data = data[23+n:]
+		n := msgpack.PutBinHead(data[22:], l)
+		data = data[22+n:]
 		copy(data, p.Data)
 		data = data[l:]
 	}
@@ -5315,25 +5322,26 @@ func (p *StoreObject) neoMsgDecodeM(data []byte) (int, error) {
 		p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
 		data = data[10:]
 	}
-	if len(data) < 23 {
-		goto overflow
+	{
+		v, tail, err := msgp.ReadUint64Bytes(data)
+		if err != nil {
+			return 0, mdecodeErr("StoreObject.Compression", err)
+		}
+		p.Compression = Compression(v)
+		nread += uint64(len(data) - len(tail))
+		data = tail
 	}
-	switch op := msgpack.Op(data[0]); op {
-	default:
-		return 0, mdecodeOpErr("StoreObject.Compression", op, msgpack.True, msgpack.False)
-	case msgpack.True:
-		p.Compression = true
-	case msgpack.False:
-		p.Compression = false
+	if len(data) < 22 {
+		goto overflow
 	}
-	if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
+	if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
 		return 0, mdecodeOpErr("StoreObject.Checksum", op, msgpack.Bin8)
 	}
-	if l := data[2]; l != 20 {
+	if l := data[1]; l != 20 {
 		return 0, mdecodeLen8Err("StoreObject.Checksum", l, 20)
 	}
-	copy(p.Checksum[:], data[3:23])
-	data = data[23:]
+	copy(p.Checksum[:], data[2:22])
+	data = data[22:]
 	{
 		b, tail, err := msgp.ReadBytesZC(data)
 		if err != nil {
@@ -6191,19 +6199,19 @@ func (*AnswerObject) neoMsgCode() uint16 {
 }
 
 func (p *AnswerObject) neoMsgEncodedLenN() int {
-	return 57 + len(p.Data.XData())
+	return 64 + len(p.Data.XData())
 }
 
 func (p *AnswerObject) neoMsgEncodeN(data []byte) {
 	binary.BigEndian.PutUint64(data[0:], uint64(p.Oid))
 	binary.BigEndian.PutUint64(data[8:], uint64(p.Serial))
 	binary.BigEndian.PutUint64(data[16:], uint64(p.NextSerial))
-	(data[24:])[0] = bool2byte(p.Compression)
-	copy(data[25:], p.Checksum[:])
+	binary.BigEndian.PutUint64(data[24:], uint64(p.Compression))
+	copy(data[32:], p.Checksum[:])
 	{
 		l := uint32(len(p.Data.XData()))
-		binary.BigEndian.PutUint32(data[45:], l)
-		data = data[49:]
+		binary.BigEndian.PutUint32(data[52:], l)
+		data = data[56:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -6212,17 +6220,17 @@ func (p *AnswerObject) neoMsgEncodeN(data []byte) {
 
 func (p *AnswerObject) neoMsgDecodeN(data []byte) (int, error) {
 	var nread uint64
-	if len(data) < 49 {
+	if len(data) < 56 {
 		goto overflow
 	}
 	p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[0 : 0+8]))
 	p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[8 : 8+8]))
 	p.NextSerial = zodb.Tid(binary.BigEndian.Uint64(data[16 : 16+8]))
-	p.Compression = byte2bool((data[24 : 24+1])[0])
-	copy(p.Checksum[:], data[25:45])
+	p.Compression = Compression(binary.BigEndian.Uint64(data[24 : 24+8]))
+	copy(p.Checksum[:], data[32:52])
 	{
-		l := binary.BigEndian.Uint32(data[45 : 45+4])
-		data = data[49:]
+		l := binary.BigEndian.Uint32(data[52 : 52+4])
+		data = data[56:]
 		if uint64(len(data)) < 8+uint64(l) {
 			goto overflow
 		}
@@ -6232,7 +6240,7 @@ func (p *AnswerObject) neoMsgDecodeN(data []byte) (int, error) {
 		data = data[l:]
 	}
 	p.DataSerial = zodb.Tid(binary.BigEndian.Uint64(data[0 : 0+8]))
-	return 49 + int(nread), nil
+	return 56 + int(nread), nil
 
 overflow:
 	return 0, ErrDecodeOverflow
@@ -6260,7 +6268,7 @@ func (p *AnswerObject) neoMsgEncodedLenM() int {
 	} else {
 		size += 1 + 1 + 8 // mbin8 + 8 + [8]data
 	}
-	return 24 + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
+	return 23 + msgpack.Uint64Size(uint64(p.Compression)) + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
 }
 
 func (p *AnswerObject) neoMsgEncodeM(data []byte) {
@@ -6292,14 +6300,17 @@ func (p *AnswerObject) neoMsgEncodeM(data []byte) {
 		binary.BigEndian.PutUint64(data[2:], uint64(p.NextSerial))
 		data = data[10:]
 	}
-	data[0] = byte(msgpack.Bool(p.Compression))
-	data[1] = byte(msgpack.Bin8)
-	data[2] = 20
-	copy(data[3:], p.Checksum[:])
+	{
+		n := msgpack.PutUint64(data[0:], uint64(p.Compression))
+		data = data[0+n:]
+	}
+	data[0] = byte(msgpack.Bin8)
+	data[1] = 20
+	copy(data[2:], p.Checksum[:])
 	{
 		l := len(p.Data.XData())
-		n := msgpack.PutBinHead(data[23:], l)
-		data = data[23+n:]
+		n := msgpack.PutBinHead(data[22:], l)
+		data = data[22+n:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -6378,25 +6389,26 @@ func (p *AnswerObject) neoMsgDecodeM(data []byte) (int, error) {
 		p.NextSerial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
 		data = data[10:]
 	}
-	if len(data) < 23 {
-		goto overflow
+	{
+		v, tail, err := msgp.ReadUint64Bytes(data)
+		if err != nil {
+			return 0, mdecodeErr("AnswerObject.Compression", err)
+		}
+		p.Compression = Compression(v)
+		nread += uint64(len(data) - len(tail))
+		data = tail
 	}
-	switch op := msgpack.Op(data[0]); op {
-	default:
-		return 0, mdecodeOpErr("AnswerObject.Compression", op, msgpack.True, msgpack.False)
-	case msgpack.True:
-		p.Compression = true
-	case msgpack.False:
-		p.Compression = false
+	if len(data) < 22 {
+		goto overflow
 	}
-	if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
+	if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
 		return 0, mdecodeOpErr("AnswerObject.Checksum", op, msgpack.Bin8)
 	}
-	if l := data[2]; l != 20 {
+	if l := data[1]; l != 20 {
 		return 0, mdecodeLen8Err("AnswerObject.Checksum", l, 20)
 	}
-	copy(p.Checksum[:], data[3:23])
-	data = data[23:]
+	copy(p.Checksum[:], data[2:22])
+	data = data[22:]
 	{
 		b, tail, err := msgp.ReadBytesZC(data)
 		if err != nil {
@@ -13307,18 +13319,18 @@ func (*AddObject) neoMsgCode() uint16 {
 }
 
 func (p *AddObject) neoMsgEncodedLenN() int {
-	return 49 + len(p.Data.XData())
+	return 56 + len(p.Data.XData())
 }
 
 func (p *AddObject) neoMsgEncodeN(data []byte) {
 	binary.BigEndian.PutUint64(data[0:], uint64(p.Oid))
 	binary.BigEndian.PutUint64(data[8:], uint64(p.Serial))
-	(data[16:])[0] = bool2byte(p.Compression)
-	copy(data[17:], p.Checksum[:])
+	binary.BigEndian.PutUint64(data[16:], uint64(p.Compression))
+	copy(data[24:], p.Checksum[:])
 	{
 		l := uint32(len(p.Data.XData()))
-		binary.BigEndian.PutUint32(data[37:], l)
-		data = data[41:]
+		binary.BigEndian.PutUint32(data[44:], l)
+		data = data[48:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -13327,16 +13339,16 @@ func (p *AddObject) neoMsgEncodeN(data []byte) {
 
 func (p *AddObject) neoMsgDecodeN(data []byte) (int, error) {
 	var nread uint64
-	if len(data) < 41 {
+	if len(data) < 48 {
 		goto overflow
 	}
 	p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[0 : 0+8]))
 	p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[8 : 8+8]))
-	p.Compression = byte2bool((data[16 : 16+1])[0])
-	copy(p.Checksum[:], data[17:37])
+	p.Compression = Compression(binary.BigEndian.Uint64(data[16 : 16+8]))
+	copy(p.Checksum[:], data[24:44])
 	{
-		l := binary.BigEndian.Uint32(data[37 : 37+4])
-		data = data[41:]
+		l := binary.BigEndian.Uint32(data[44 : 44+4])
+		data = data[48:]
 		if uint64(len(data)) < 8+uint64(l) {
 			goto overflow
 		}
@@ -13346,7 +13358,7 @@ func (p *AddObject) neoMsgDecodeN(data []byte) (int, error) {
 		data = data[l:]
 	}
 	p.DataSerial = zodb.Tid(binary.BigEndian.Uint64(data[0 : 0+8]))
-	return 41 + int(nread), nil
+	return 48 + int(nread), nil
 
 overflow:
 	return 0, ErrDecodeOverflow
@@ -13369,7 +13381,7 @@ func (p *AddObject) neoMsgEncodedLenM() int {
 	} else {
 		size += 1 + 1 + 8 // mbin8 + 8 + [8]data
 	}
-	return 24 + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
+	return 23 + msgpack.Uint64Size(uint64(p.Compression)) + msgpack.BinHeadSize(len(p.Data.XData())) + len(p.Data.XData()) + size
 }
 
 func (p *AddObject) neoMsgEncodeM(data []byte) {
@@ -13392,14 +13404,17 @@ func (p *AddObject) neoMsgEncodeM(data []byte) {
 		binary.BigEndian.PutUint64(data[2:], uint64(p.Serial))
 		data = data[10:]
 	}
-	data[0] = byte(msgpack.Bool(p.Compression))
-	data[1] = byte(msgpack.Bin8)
-	data[2] = 20
-	copy(data[3:], p.Checksum[:])
+	{
+		n := msgpack.PutUint64(data[0:], uint64(p.Compression))
+		data = data[0+n:]
+	}
+	data[0] = byte(msgpack.Bin8)
+	data[1] = 20
+	copy(data[2:], p.Checksum[:])
 	{
 		l := len(p.Data.XData())
-		n := msgpack.PutBinHead(data[23:], l)
-		data = data[23+n:]
+		n := msgpack.PutBinHead(data[22:], l)
+		data = data[22+n:]
 		copy(data, p.Data.XData())
 		data = data[l:]
 	}
@@ -13461,25 +13476,26 @@ func (p *AddObject) neoMsgDecodeM(data []byte) (int, error) {
 		p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
 		data = data[10:]
 	}
-	if len(data) < 23 {
-		goto overflow
+	{
+		v, tail, err := msgp.ReadUint64Bytes(data)
+		if err != nil {
+			return 0, mdecodeErr("AddObject.Compression", err)
+		}
+		p.Compression = Compression(v)
+		nread += uint64(len(data) - len(tail))
+		data = tail
 	}
-	switch op := msgpack.Op(data[0]); op {
-	default:
-		return 0, mdecodeOpErr("AddObject.Compression", op, msgpack.True, msgpack.False)
-	case msgpack.True:
-		p.Compression = true
-	case msgpack.False:
-		p.Compression = false
+	if len(data) < 22 {
+		goto overflow
 	}
-	if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
+	if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
 		return 0, mdecodeOpErr("AddObject.Checksum", op, msgpack.Bin8)
 	}
-	if l := data[2]; l != 20 {
+	if l := data[1]; l != 20 {
 		return 0, mdecodeLen8Err("AddObject.Checksum", l, 20)
 	}
-	copy(p.Checksum[:], data[3:23])
-	data = data[23:]
+	copy(p.Checksum[:], data[2:22])
+	data = data[22:]
 	{
 		b, tail, err := msgp.ReadBytesZC(data)
 		if err != nil {

go/neo/storage/fs1/fs1.go

@@ -87,7 +87,7 @@ func (f *Backend) Load(ctx context.Context, xid zodb.Xid) (*proto.AnswerObject,
 		Serial:     serial,
 		NextSerial: nextSerial,
 
-		Compression: false,
+		Compression: 0,
 		Data:        buf,
 		Checksum:    xsha1.NEOSum(buf.Data),	// XXX computing every time