// GetEndorserClient returns a new endorser client connection for this peer
func GetEndorserClient() (pb.EndorserClient, error) {
clientConn, err := peer.NewPeerClientConnection()
if err != nil {
err = errors.ErrorWithCallstack(errors.Peer, errors.PeerConnectionError, err.Error())
return nil, err
}
endorserClient := pb.NewEndorserClient(clientConn)
return endorserClient, nil
}
func (b *BDDContext) invokeOnWithTimeout(composeServices []string, timeoutInSecs string, callBack func(context.Context, pb.EndorserClient) (proposalResponse *pb.ProposalResponse, err error)) (map[string]*pb.ProposalResponse, error) {
var err error
resultsMap := make(map[string]*pb.ProposalResponse)
errRetFunc := func() error {
return fmt.Errorf("Error when invoking endorser(s) on '%s': %s", composeServices, err)
}
var (
durationToWait time.Duration
ctx context.Context
cancel context.CancelFunc
)
if durationToWait, err = time.ParseDuration(fmt.Sprintf("%ss", timeoutInSecs)); err != nil {
return nil, errRetFunc()
}
ctx, cancel = context.WithTimeout(context.Background(), durationToWait)
defer cancel()
cancel()
for _, cs := range composeServices {
go func(composeService string) {
var proposalResponse *pb.ProposalResponse
// Now use the endorser client to create the send the proposal
println("Calling endorser for compose service:", composeService)
var grpcClient *grpc.ClientConn
if grpcClient, err = NewGrpcClient("172.17.0.4:7051"); err != nil {
return
}
defer grpcClient.Close()
endorserClient := pb.NewEndorserClient(grpcClient)
if proposalResponse, err = callBack(ctx, endorserClient); err != nil {
return
}
resultsMap[composeService] = proposalResponse
}(cs)
}
return resultsMap, err
}
func (b *BDDContext) userSendsProposalToEndorsersWithTimeoutOfSeconds(enrollID, proposalAlias, timeoutInSecs string, endorsersTable *gherkin.DataTable) (err error) {
var proposal *pb.Proposal
var keyedProposalResponsesMap KeyedProposalResponseMap
keyedProposalResponsesMap = make(KeyedProposalResponseMap)
errRetFunc := func() error {
return fmt.Errorf("Error sending proposal '%s' for user '%s': %s", proposalAlias, enrollID, err)
}
var userRegistration *UserRegistration
if userRegistration, err = b.GetUserRegistration(enrollID); err != nil {
return errRetFunc()
}
// Get the proposal from the user
if proposal, err = userRegistration.GetProposal(proposalAlias); err != nil {
return errRetFunc()
}
var ctx context.Context
var cancel context.CancelFunc
if ctx, cancel, err = getContextAndCancelForTimeoutInSecs(context.Background(), timeoutInSecs); err != nil {
return errRetFunc()
}
defer cancel()
// Loop through endorsers and send proposals
var endorsers []string
if endorsers, err = b.GetArgsForUser(endorsersTable.Rows[0].Cells, userRegistration); err != nil {
return errRetFunc()
}
respQueue := make(chan *KeyedProposalResponse)
for _, e := range endorsers {
go func(endorser string) {
var localErr error
var proposalResponse *pb.ProposalResponse
// Now use the endorser client to send the proposal
var grpcClient *grpc.ClientConn
if grpcClient, localErr = b.getGrpcClientForComposeService(endorser); localErr != nil {
respQueue <- &KeyedProposalResponse{endorser, nil, fmt.Errorf("Error calling endorser '%s': %s", endorser, localErr)}
return
}
defer grpcClient.Close()
proposalBytes, err := utils.GetBytesProposal(proposal)
if err != nil {
respQueue <- &KeyedProposalResponse{endorser, nil, fmt.Errorf("Error serializing proposal bytes")}
return
}
// FIXME: the endorser needs to be given a signed proposal - who should sign?
signedProposal := &pb.SignedProposal{ProposalBytes: proposalBytes, Signature: []byte("signature")}
endorserClient := pb.NewEndorserClient(grpcClient)
if proposalResponse, localErr = endorserClient.ProcessProposal(ctx, signedProposal); localErr != nil {
respQueue <- &KeyedProposalResponse{endorser, nil, fmt.Errorf("Error calling endorser '%s': %s", endorser, localErr)}
return
}
respQueue <- &KeyedProposalResponse{endorser, proposalResponse, nil}
}(e)
}
go func() {
for i := 0; i < len(endorsers); i++ {
result := <-respQueue
keyedProposalResponsesMap[result.endorser] = result
if result.err != nil {
// TODO: think about whether to break on first failure, or allow to collect
}
}
cancel()
}()
<-ctx.Done()
if ctx.Err() != context.Canceled {
err = ctx.Err()
return errRetFunc()
}
userRegistration.lastResult = keyedProposalResponsesMap
return nil
}