Merge branch 'cal/vote-extensions-1' into cal/vote-extensions-2

proxy/app_conn.go

@@ -27,9 +27,11 @@ type AppConnConsensus interface {
 }
 
 type AppConnMempool interface {
+	SetResponseCallback(abcicli.Callback)
 	Error() error
 
 	CheckTx(context.Context, *types.RequestCheckTx) (*types.ResponseCheckTx, error)
+	CheckTxAsync(context.Context, *types.RequestCheckTx) (*abcicli.ReqRes, error)
 	Flush(context.Context) error
 }
 
@@ -123,6 +125,10 @@ func NewAppConnMempool(appConn abcicli.Client, metrics *Metrics) AppConnMempool
 	}
 }
 
+func (app *appConnMempool) SetResponseCallback(cb abcicli.Callback) {
+	app.appConn.SetResponseCallback(cb)
+}
+
 func (app *appConnMempool) Error() error {
 	return app.appConn.Error()
 }
@@ -137,6 +143,11 @@ func (app *appConnMempool) CheckTx(ctx context.Context, req *types.RequestCheckT
 	return app.appConn.CheckTx(ctx, req)
 }
 
+func (app *appConnMempool) CheckTxAsync(ctx context.Context, req *types.RequestCheckTx) (*abcicli.ReqRes, error) {
+	defer addTimeSample(app.metrics.MethodTimingSeconds.With("method", "check_tx", "type", "async"))()
+	return app.appConn.CheckTxAsync(ctx, req)
+}
+
 //------------------------------------------------
 // Implements AppConnQuery (subset of abcicli.Client)
 

proxy/client.go

@@ -39,6 +39,26 @@ func (l *localClientCreator) NewABCIClient() (abcicli.Client, error) {
 	return abcicli.NewLocalClient(l.mtx, l.app), nil
 }
 
+//---------------------------------------------------------------
+// unsynchronized local proxy on an in-proc app (no mutex)
+
+type unsyncLocalClientCreator struct {
+	app types.Application
+}
+
+// NewUnsyncLocalClientCreator returns a ClientCreator for the given app, which
+// will be running locally. Unlike NewLocalClientCreator, this leaves
+// synchronization up to the application.
+func NewUnsyncLocalClientCreator(app types.Application) ClientCreator {
+	return &unsyncLocalClientCreator{
+		app: app,
+	}
+}
+
+func (l *unsyncLocalClientCreator) NewABCIClient() (abcicli.Client, error) {
+	return abcicli.NewUnsyncLocalClient(l.app), nil
+}
+
 //---------------------------------------------------------------
 // remote proxy opens new connections to an external app process
 
@@ -83,6 +103,12 @@ func DefaultClientCreator(addr, transport, dbDir string) ClientCreator {
 			panic(err)
 		}
 		return NewLocalClientCreator(app)
+	case "e2e_sync":
+		app, err := e2e.NewSyncApplication(e2e.DefaultConfig(dbDir))
+		if err != nil {
+			panic(err)
+		}
+		return NewUnsyncLocalClientCreator(app)
 	case "noop":
 		return NewLocalClientCreator(types.NewBaseApplication())
 	default:

proxy/mocks/app_conn_mempool.go

@@ -5,6 +5,8 @@ package mocks
 import (
 	context "context"
 
+	abcicli "github.com/tendermint/tendermint/abci/client"
+
 	mock "github.com/stretchr/testify/mock"
 
 	types "github.com/tendermint/tendermint/abci/types"
@@ -38,6 +40,29 @@ func (_m *AppConnMempool) CheckTx(_a0 context.Context, _a1 *types.RequestCheckTx
 	return r0, r1
 }
 
+// CheckTxAsync provides a mock function with given fields: _a0, _a1
+func (_m *AppConnMempool) CheckTxAsync(_a0 context.Context, _a1 *types.RequestCheckTx) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, *types.RequestCheckTx) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *types.RequestCheckTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // Error provides a mock function with given fields:
 func (_m *AppConnMempool) Error() error {
 	ret := _m.Called()