.

go/neo/client.go

@@ -388,6 +388,7 @@ func (c *Client) LastTid(ctx context.Context) (_ zodb.Tid, err error) {
 	reply := proto.AnswerLastTransaction{}
 	err = mlink.Ask1(&proto.LastTransaction{}, &reply) // XXX Ask += ctx
 	if err != nil {
+		// XXX ZODBErrDecode?
 		return 0, err	// XXX err ctx
 	}
 	return reply.Tid, nil
@@ -449,6 +450,9 @@ func (c *Client) _Load(ctx context.Context, xid zodb.Xid) (*mem.Buf, zodb.Tid, e
 	resp := proto.AnswerObject{}
 	err = slink.Ask1(&req, &resp)
 	if err != nil {
+		if e, ok := err.(*proto.Error); ok {
+			err = proto.ZODBErrDecode(e)
+		}
 		return nil, 0, err	// XXX err context
 	}
 

go/neo/neo_test.go

@@ -467,7 +467,7 @@ func benchmarkGetObject(b *testing.B, Mnet, Snet, Cnet xnet.Networker, benchit f
 		return M.Run(ctx)
 	})
 
-	// determing M serving address	XXX better with M api
+	// determining M serving address	XXX better with M api
 	ev := cG.Recv()
 	mnode, ok := ev.Event.(*eventNodeTab)
 	if !ok {

go/neo/neonet/connection.go

@@ -1411,12 +1411,14 @@ func (c *Conn) _Expect(pkt *pktBuf, msgv ...proto.Msg) (int, error) {
 	return -1, c.err("recv", fmt.Errorf("unexpected message: %v", msgType))
 }
 
-// Ask sends request and receives response.
+// Ask sends request and receives a response.
 //
-// It expects response to be exactly of resp type and errors otherwise.
+// It expects response to be either of resp type or proto.Error:
 //
-// XXX clarify error semantic (when Error is decoded)
-// XXX do the same as Expect wrt respv ?
+// If resp-type message is received, it is decoded inplace and nil is returned.
+// If proto.Error message is received, it is returned as error.
+//
+// Otherwise returned error describes the problem.
 func (c *Conn) Ask(req proto.Msg, resp proto.Msg) error {
 	err := c.Send(req)
 	if err != nil {
@@ -1429,7 +1431,7 @@ func (c *Conn) Ask(req proto.Msg, resp proto.Msg) error {
 	case 0:
 		return nil
 	case 1:
-		return proto.ErrDecode(nerr)
+		return nerr
 	}
 
 	return err
@@ -1566,7 +1568,7 @@ func (conn *Conn) _Ask1(req proto.Msg, resp proto.Msg) error {
 	case 0:
 		return nil
 	case 1:
-		return proto.ErrDecode(nerr)
+		return nerr
 	}
 
 	return err

go/neo/proto/error.go

@@ -26,15 +26,22 @@ import (
 	"lab.nexedi.com/kirr/neo/go/zodb"
 )
 
-// XXX name -> zodbErrEncode, zodbErrDecode ?
 // XXX should be not in proto/ ?
 
-// ErrEncode translates an error into Error packet.
-// XXX more text describing relation with zodb errors
-func ErrEncode(err error) *Error {
+// ZODBErrEncode translates a ZODB error into Error packet.
+//
+// ZODB errors (e.g. zodb.NoDataError) are specifically encoded, so that on
+// receiver side they can be recreated with ErrDecode. If err is zodb.OpError,
+// only its inner cause is encoded.
+//
+// If err is not ZODB error -> it is incoded as "503".
+func ZODBErrEncode(err error) *Error {
+	e, ok := err.(*zodb.OpError)
+	if ok {
+		err = e.Err
+	}
+
 	switch err := err.(type) {
-	case *Error:
-		return err
 	case *zodb.NoDataError:
 		// XXX abusing message for oid, deletedAt
 		return &Error{
@@ -52,9 +59,11 @@ func ErrEncode(err error) *Error {
 
 }
 
-// ErrDecode decodes error from Error packet.
-// XXX more text describing relation with zodb errors
-func ErrDecode(e *Error) error {
+// ZODBErrDecode decodes an error from Error packet.
+//
+// If it was ZODB error - it is decoded from the packet and returned.
+// Otherwise e is returned as is.
+func ZODBErrDecode(e *Error) error {
 	switch e.Code {
 	case OID_NOT_FOUND:
 		// XXX abusing message for oid, deletedAt

go/neo/storage.go

@@ -542,8 +542,7 @@ func (stor *Storage) serveClient1(ctx context.Context, req proto.Msg) (resp prot
 		obj, err := stor.back.Load(ctx, xid)
 		if err != nil {
 			// translate err to NEO protocol error codes
-			e := err.(*zodb.OpError)	// XXX move this to ErrEncode?
-			return proto.ErrEncode(e.Err)
+			return proto.ZODBErrEncode(err)
 		}
 
 		// compatibility with py side:
@@ -562,7 +561,7 @@ func (stor *Storage) serveClient1(ctx context.Context, req proto.Msg) (resp prot
 	case *proto.LastTransaction:
 		lastTid, err := stor.back.LastTid(ctx)
 		if err != nil {
-			return proto.ErrEncode(err)
+			return proto.ZODBErrEncode(err)
 		}
 
 		return &proto.AnswerLastTransaction{lastTid}