just need to reimplement error handling but not bad this time

lib/bouncer/bouncers/v2/bctx/context.go

@@ -57,3 +57,11 @@ func (T *Context) ClientProxy(in zap.In) berr.Error {
 func (T *Context) ServerProxy(in zap.In) berr.Error {
 	return T.ServerSend(zap.InToOut(in))
 }
+
+func (T *Context) ClientWrite() zap.Out {
+	return T.client.Write()
+}
+
+func (T *Context) ServerWrite() zap.Out {
+	return T.server.Write()
+}

lib/bouncer/bouncers/v2/berr/client.go

@@ -8,6 +8,4 @@ func MakeClient(err error) Client {
 	return Client{err}
 }
 
-func (Client) Source() Source {
-	return CLIENT
-}
+func (Client) err() {}

lib/bouncer/bouncers/v2/berr/error.go

@@ -2,5 +2,5 @@ package berr
 
 type Error interface {
 	error
-	Source() Source
+	err()
 }

lib/bouncer/bouncers/v2/berr/errors.go

@@ -3,8 +3,8 @@ package berr
 import "errors"
 
 var (
-	ServerBadPacket        = MakeServer(errors.New("bad packet format from server"))
-	ServerUnexpectedPacket = MakeServer(errors.New("unexpected packet from server"))
+	ServerBadPacket        = MakeServer(errors.New("bad packet format"))
+	ServerUnexpectedPacket = MakeServer(errors.New("unexpected packet"))
 
-	ClientUnexpectedPacket = MakeClient(errors.New("unexpected packet from client"))
+	ClientUnexpectedPacket = MakeClient(errors.New("unexpected packet"))
 )

lib/bouncer/bouncers/v2/berr/server.go

@@ -8,6 +8,4 @@ func MakeServer(err error) Server {
 	return Server{err}
 }
 
-func (Server) Source() Source {
-	return SERVER
-}
+func (Server) err() {}

lib/bouncer/bouncers/v2/berr/source.go

-package berr
-
-type Source int
-
-const (
-	SERVER Source = iota
-	CLIENT
-)

lib/bouncer/bouncers/v2/bouncer.go

@@ -5,6 +5,9 @@ import (
 
 	"pggat2/lib/bouncer/bouncers/v2/bctx"
 	"pggat2/lib/bouncer/bouncers/v2/berr"
+	"pggat2/lib/bouncer/bouncers/v2/rclient"
+	"pggat2/lib/bouncer/bouncers/v2/rserver"
+	"pggat2/lib/perror"
 	"pggat2/lib/zap"
 	packets "pggat2/lib/zap/packets/v3.0"
 )
@@ -195,10 +198,6 @@ func eqp(ctx *bctx.Context) berr.Error {
 
 func transaction(ctx *bctx.Context) berr.Error {
 	for {
-		if ctx.TxState == 'I' {
-			return nil
-		}
-
 		in, err := ctx.ClientRead()
 		if err != nil {
 			return err
@@ -220,11 +219,10 @@ func transaction(ctx *bctx.Context) berr.Error {
 				return err
 			}
 		case packets.Sync:
-			// TODO(garet) can this be turned into a phony call, not actually directed to server?
-			if err = ctx.ServerProxy(in); err != nil {
-				return err
-			}
-			if err = sync(ctx); err != nil {
+			// phony sync call, we can just reply with a fake ReadyForQuery(TxState)
+			out := zap.InToOut(in)
+			packets.WriteReadyForQuery(out, ctx.TxState)
+			if err = ctx.ClientSend(out); err != nil {
 				return err
 			}
 		case packets.Parse, packets.Bind, packets.Close, packets.Describe, packets.Execute, packets.Flush:
@@ -237,14 +235,45 @@ func transaction(ctx *bctx.Context) berr.Error {
 		default:
 			return berr.ClientUnexpectedPacket
 		}
+
+		if ctx.TxState == 'I' {
+			return nil
+		}
 	}
 }
 
+func clientError(ctx *bctx.Context, err error) {
+	// send fatal error to client
+	out := ctx.ClientWrite()
+	packets.WriteErrorResponse(out, perror.New(
+		perror.FATAL,
+		perror.ProtocolViolation,
+		err.Error(),
+	))
+	_ = ctx.ClientSend(out)
+}
+
+func serverError(ctx *bctx.Context, err error) {
+	panic("server error: " + err.Error())
+}
+
 func Bounce(client, server zap.ReadWriter) {
 	ctx := bctx.MakeContext(client, server)
-	ctx.TxState = 'T'
 	err := transaction(&ctx)
 	if err != nil {
-		panic(err)
+		switch e := err.(type) {
+		case berr.Client:
+			clientError(&ctx, e)
+			if err2 := rserver.Recover(&ctx); err2 != nil {
+				serverError(&ctx, err2)
+			}
+		case berr.Server:
+			serverError(&ctx, e)
+			if err2 := rclient.Recover(&ctx); err2 != nil {
+				clientError(&ctx, err2)
+			}
+		default:
+			panic("unreachable")
+		}
 	}
 }