github.com/myafeier/fabric@v1.0.1-0.20170722181825-3a4b1f2bce86/core/deliverservice/mocks/orderer.go (about) 1 /* 2 Copyright IBM Corp. 2017 All Rights Reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package mocks 18 19 import ( 20 "fmt" 21 "net" 22 "sync/atomic" 23 "testing" 24 25 "github.com/golang/protobuf/proto" 26 "github.com/hyperledger/fabric/protos/common" 27 "github.com/hyperledger/fabric/protos/orderer" 28 "github.com/stretchr/testify/assert" 29 "google.golang.org/grpc" 30 ) 31 32 type Orderer struct { 33 net.Listener 34 *grpc.Server 35 nextExpectedSeek uint64 36 t *testing.T 37 blockChannel chan uint64 38 stopChan chan struct{} 39 failFlag int32 40 connCount uint32 41 } 42 43 func NewOrderer(port int, t *testing.T) *Orderer { 44 srv := grpc.NewServer() 45 lsnr, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", port)) 46 if err != nil { 47 panic(err) 48 } 49 go srv.Serve(lsnr) 50 o := &Orderer{Server: srv, 51 Listener: lsnr, 52 t: t, 53 nextExpectedSeek: uint64(1), 54 blockChannel: make(chan uint64, 1), 55 stopChan: make(chan struct{}, 1), 56 } 57 orderer.RegisterAtomicBroadcastServer(srv, o) 58 return o 59 } 60 61 func (o *Orderer) Shutdown() { 62 o.stopChan <- struct{}{} 63 o.Server.Stop() 64 o.Listener.Close() 65 } 66 67 func (o *Orderer) Fail() { 68 atomic.StoreInt32(&o.failFlag, int32(1)) 69 o.blockChannel <- 0 70 } 71 72 func (o *Orderer) ConnCount() int { 73 return int(atomic.LoadUint32(&o.connCount)) 74 } 75 76 func (o *Orderer) hasFailed() bool { 77 return atomic.LoadInt32(&o.failFlag) == int32(1) 78 } 79 80 func (*Orderer) Broadcast(orderer.AtomicBroadcast_BroadcastServer) error { 81 panic("Should not have ben called") 82 } 83 84 func (o *Orderer) SetNextExpectedSeek(seq uint64) { 85 atomic.StoreUint64(&o.nextExpectedSeek, uint64(seq)) 86 } 87 88 func (o *Orderer) SendBlock(seq uint64) { 89 o.blockChannel <- seq 90 } 91 92 func (o *Orderer) Deliver(stream orderer.AtomicBroadcast_DeliverServer) error { 93 atomic.AddUint32(&o.connCount, 1) 94 envlp, err := stream.Recv() 95 if err != nil { 96 return nil 97 } 98 if o.hasFailed() { 99 return stream.Send(statusUnavailable()) 100 } 101 payload := &common.Payload{} 102 proto.Unmarshal(envlp.Payload, payload) 103 seekInfo := &orderer.SeekInfo{} 104 proto.Unmarshal(payload.Data, seekInfo) 105 assert.True(o.t, seekInfo.Behavior == orderer.SeekInfo_BLOCK_UNTIL_READY) 106 assert.Equal(o.t, atomic.LoadUint64(&o.nextExpectedSeek), seekInfo.Start.GetSpecified().Number) 107 108 for { 109 select { 110 case <-o.stopChan: 111 return nil 112 case seq := <-o.blockChannel: 113 if o.hasFailed() { 114 return stream.Send(statusUnavailable()) 115 } 116 o.sendBlock(stream, seq) 117 } 118 } 119 } 120 121 func statusUnavailable() *orderer.DeliverResponse { 122 return &orderer.DeliverResponse{ 123 Type: &orderer.DeliverResponse_Status{ 124 Status: common.Status_SERVICE_UNAVAILABLE, 125 }, 126 } 127 } 128 129 func (o *Orderer) sendBlock(stream orderer.AtomicBroadcast_DeliverServer, seq uint64) { 130 block := &common.Block{ 131 Header: &common.BlockHeader{ 132 Number: seq, 133 }, 134 } 135 stream.Send(&orderer.DeliverResponse{ 136 Type: &orderer.DeliverResponse_Block{Block: block}, 137 }) 138 }