vendor/github.com/tendermint/abci/client/client.go

   1 package abcicli
   2
   3 import (
   4         "fmt"
   5         "sync"
   6
   7         "github.com/tendermint/abci/types"
   8         cmn "github.com/tendermint/tmlibs/common"
   9 )
  10
  11 type Client interface {
  12         cmn.Service
  13
  14         SetResponseCallback(Callback)
  15         Error() error
  16
  17         FlushAsync() *ReqRes
  18         EchoAsync(msg string) *ReqRes
  19         InfoAsync(types.RequestInfo) *ReqRes
  20         SetOptionAsync(key string, value string) *ReqRes
  21         DeliverTxAsync(tx []byte) *ReqRes
  22         CheckTxAsync(tx []byte) *ReqRes
  23         QueryAsync(types.RequestQuery) *ReqRes
  24         CommitAsync() *ReqRes
  25
  26         FlushSync() error
  27         EchoSync(msg string) (res types.Result)
  28         InfoSync(types.RequestInfo) (resInfo types.ResponseInfo, err error)
  29         SetOptionSync(key string, value string) (res types.Result)
  30         DeliverTxSync(tx []byte) (res types.Result)
  31         CheckTxSync(tx []byte) (res types.Result)
  32         QuerySync(types.RequestQuery) (resQuery types.ResponseQuery, err error)
  33         CommitSync() (res types.Result)
  34
  35         InitChainAsync(types.RequestInitChain) *ReqRes
  36         BeginBlockAsync(types.RequestBeginBlock) *ReqRes
  37         EndBlockAsync(height uint64) *ReqRes
  38
  39         InitChainSync(types.RequestInitChain) (err error)
  40         BeginBlockSync(types.RequestBeginBlock) (err error)
  41         EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error)
  42 }
  43
  44 //----------------------------------------
  45
  46 // NewClient returns a new ABCI client of the specified transport type.
  47 // It returns an error if the transport is not "socket" or "grpc"
  48 func NewClient(addr, transport string, mustConnect bool) (client Client, err error) {
  49         switch transport {
  50         case "socket":
  51                 client = NewSocketClient(addr, mustConnect)
  52         case "grpc":
  53                 client = NewGRPCClient(addr, mustConnect)
  54         default:
  55                 err = fmt.Errorf("Unknown abci transport %s", transport)
  56         }
  57         return
  58 }
  59
  60 //----------------------------------------
  61
  62 type Callback func(*types.Request, *types.Response)
  63
  64 //----------------------------------------
  65
  66 type ReqRes struct {
  67         *types.Request
  68         *sync.WaitGroup
  69         *types.Response // Not set atomically, so be sure to use WaitGroup.
  70
  71         mtx  sync.Mutex
  72         done bool                  // Gets set to true once *after* WaitGroup.Done().
  73         cb   func(*types.Response) // A single callback that may be set.
  74 }
  75
  76 func NewReqRes(req *types.Request) *ReqRes {
  77         return &ReqRes{
  78                 Request:   req,
  79                 WaitGroup: waitGroup1(),
  80                 Response:  nil,
  81
  82                 done: false,
  83                 cb:   nil,
  84         }
  85 }
  86
  87 // Sets the callback for this ReqRes atomically.
  88 // If reqRes is already done, calls cb immediately.
  89 // NOTE: reqRes.cb should not change if reqRes.done.
  90 // NOTE: only one callback is supported.
  91 func (reqRes *ReqRes) SetCallback(cb func(res *types.Response)) {
  92         reqRes.mtx.Lock()
  93
  94         if reqRes.done {
  95                 reqRes.mtx.Unlock()
  96                 cb(reqRes.Response)
  97                 return
  98         }
  99
 100         defer reqRes.mtx.Unlock()
 101         reqRes.cb = cb
 102 }
 103
 104 func (reqRes *ReqRes) GetCallback() func(*types.Response) {
 105         reqRes.mtx.Lock()
 106         defer reqRes.mtx.Unlock()
 107         return reqRes.cb
 108 }
 109
 110 // NOTE: it should be safe to read reqRes.cb without locks after this.
 111 func (reqRes *ReqRes) SetDone() {
 112         reqRes.mtx.Lock()
 113         reqRes.done = true
 114         reqRes.mtx.Unlock()
 115 }
 116
 117 func waitGroup1() (wg *sync.WaitGroup) {
 118         wg = &sync.WaitGroup{}
 119         wg.Add(1)
 120         return
 121 }