func (p *PeerImpl) chatWithPeer(peerAddress string) error {
if len(peerAddress) == 0 {
peerLogger.Debug("Starting up the first peer")
return nil // nothing to do
}
for {
time.Sleep(1 * time.Second)
peerLogger.Debug("Initiating Chat with peer address: %s", peerAddress)
conn, err := NewPeerClientConnectionWithAddress(peerAddress)
if err != nil {
e := fmt.Errorf("Error creating connection to peer address=%s: %s", peerAddress, err)
peerLogger.Error(e.Error())
continue
}
serverClient := pb.NewPeerClient(conn)
ctx := context.Background()
stream, err := serverClient.Chat(ctx)
if err != nil {
e := fmt.Errorf("Error establishing chat with peer address=%s: %s", peerAddress, err)
peerLogger.Error(fmt.Sprintf("%s", e.Error()))
continue
}
peerLogger.Debug("Established Chat with peer address: %s", peerAddress)
err = p.handleChat(ctx, stream, true)
stream.CloseSend()
if err != nil {
e := fmt.Errorf("Ending chat with peer address=%s due to error: %s", peerAddress, err)
peerLogger.Error(e.Error())
return e
}
}
}
// SendTransactionsToPeer forwards transactions to the specified peer address.
func (p *PeerImpl) SendTransactionsToPeer(peerAddress string, transaction *pb.Transaction) (response *pb.Response) {
conn, err := NewPeerClientConnectionWithAddress(peerAddress)
if err != nil {
return &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(fmt.Sprintf("Error creating client to peer address=%s: %s", peerAddress, err))}
}
defer conn.Close()
serverClient := pb.NewPeerClient(conn)
peerLogger.Debugf("Sending TX to Peer: %s", peerAddress)
response, err = serverClient.ProcessTransaction(context.Background(), transaction)
if err != nil {
return &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(fmt.Sprintf("Error calling ProcessTransaction on remote peer at address=%s: %s", peerAddress, err))}
}
return response
}
func performChat(t testing.TB, conn *grpc.ClientConn) error {
serverClient := pb.NewPeerClient(conn)
stream, err := serverClient.Chat(context.Background())
if err != nil {
t.Logf("%v.performChat(_) = _, %v", serverClient, err)
return err
}
defer stream.CloseSend()
t.Log("Starting performChat")
waitc := make(chan struct{})
go func() {
// Be sure to close the channel
defer close(waitc)
for {
in, err := stream.Recv()
if err == io.EOF {
t.Logf("Received EOR, exiting chat")
return
}
if err != nil {
t.Errorf("stream closed with unexpected error: %s", err)
return
}
if in.Type == pb.Message_DISC_HELLO {
t.Logf("Received message: %s, sending %s", in.Type, pb.Message_DISC_GET_PEERS)
stream.Send(&pb.Message{Type: pb.Message_DISC_GET_PEERS})
} else if in.Type == pb.Message_DISC_PEERS {
//stream.Send(&pb.DiscoveryMessage{Type: pb.DiscoveryMessage_PEERS})
t.Logf("Received message: %s", in.Type)
t.Logf("Closing stream and channel")
return
} else {
t.Logf("Received message: %s", in.Type)
}
}
}()
select {
case <-waitc:
return nil
case <-time.After(1 * time.Second):
t.Fail()
return fmt.Errorf("Timeout expired while performChat")
}
}
func initPeerClient() (err error) {
config.SetupTestConfig(".")
viper.Set("ledger.blockchain.deploy-system-chaincode", "false")
viper.Set("peer.validator.validity-period.verification", "false")
peerClientConn, err = peer.NewPeerClientConnection()
if err != nil {
fmt.Printf("error connection to server at host:port = %s\n", viper.GetString("peer.address"))
return
}
serverClient = pb.NewPeerClient(peerClientConn)
// Logging
var formatter = logging.MustStringFormatter(
`%{color}[%{module}] %{shortfunc} [%{shortfile}] -> %{level:.4s} %{id:03x}%{color:reset} %{message}`,
)
logging.SetFormatter(formatter)
return
}
func (p *PeerImpl) chatWithPeer(peerAddress string, chatTokens chan token) error {
for {
time.Sleep(1 * time.Second)
// acquire token
chatTokens <- token{}
peerLogger.Debugf("Initiating Chat with peer address: %s", peerAddress)
conn, err := NewPeerClientConnectionWithAddress(peerAddress)
if err != nil {
e := fmt.Errorf("Error creating connection to peer address=%s: %s", peerAddress, err)
peerLogger.Error(e.Error())
// relinquish token
<-chatTokens
continue
}
serverClient := pb.NewPeerClient(conn)
ctx := context.Background()
stream, err := serverClient.Chat(ctx)
if err != nil {
e := fmt.Errorf("Error establishing chat with peer address=%s: %s", peerAddress, err)
peerLogger.Errorf("%s", e.Error())
// relinquish token
<-chatTokens
continue
}
peerLogger.Debugf("Established Chat with peer address: %s", peerAddress)
err = p.handleChat(ctx, stream, true)
stream.CloseSend()
if err != nil {
e := fmt.Errorf("Ending chat with peer address=%s due to error: %s", peerAddress, err)
peerLogger.Error(e.Error())
return e
}
}
}
func (p *PeerImpl) chatWithPeer(address string) error {
peerLogger.Debugf("Initiating Chat with peer address: %s", address)
conn, err := NewPeerClientConnectionWithAddress(address)
if err != nil {
peerLogger.Errorf("Error creating connection to peer address %s: %s", address, err)
return err
}
serverClient := pb.NewPeerClient(conn)
ctx := context.Background()
stream, err := serverClient.Chat(ctx)
if err != nil {
peerLogger.Errorf("Error establishing chat with peer address %s: %s", address, err)
return err
}
peerLogger.Debugf("Established Chat with peer address: %s", address)
err = p.handleChat(ctx, stream, true)
stream.CloseSend()
if err != nil {
peerLogger.Errorf("Ending Chat with peer address %s due to error: %s", address, err)
return err
}
return nil
}