github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/orderer/sample_clients/deliver_stdout/client.go (about)

     1  // Copyright hechain. All Rights Reserved.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package main
     5  
     6  import (
     7  	"context"
     8  	"flag"
     9  	"fmt"
    10  	"math"
    11  	"os"
    12  
    13  	"github.com/hechain20/hechain/bccsp/factory"
    14  	"github.com/hechain20/hechain/internal/pkg/identity"
    15  	"github.com/hechain20/hechain/msp"
    16  	mspmgmt "github.com/hechain20/hechain/msp/mgmt"
    17  	"github.com/hechain20/hechain/orderer/common/localconfig"
    18  	"github.com/hechain20/hechain/protoutil"
    19  	"github.com/hyperledger/fabric-config/protolator"
    20  	cb "github.com/hyperledger/fabric-protos-go/common"
    21  	ab "github.com/hyperledger/fabric-protos-go/orderer"
    22  	"google.golang.org/grpc"
    23  )
    24  
    25  var (
    26  	oldest  = &ab.SeekPosition{Type: &ab.SeekPosition_Oldest{Oldest: &ab.SeekOldest{}}}
    27  	newest  = &ab.SeekPosition{Type: &ab.SeekPosition_Newest{Newest: &ab.SeekNewest{}}}
    28  	maxStop = &ab.SeekPosition{Type: &ab.SeekPosition_Specified{Specified: &ab.SeekSpecified{Number: math.MaxUint64}}}
    29  )
    30  
    31  type deliverClient struct {
    32  	client    ab.AtomicBroadcast_DeliverClient
    33  	channelID string
    34  	signer    identity.SignerSerializer
    35  	quiet     bool
    36  }
    37  
    38  func newDeliverClient(client ab.AtomicBroadcast_DeliverClient, channelID string, signer identity.SignerSerializer, quiet bool) *deliverClient {
    39  	return &deliverClient{client: client, channelID: channelID, signer: signer, quiet: quiet}
    40  }
    41  
    42  func (r *deliverClient) seekHelper(start *ab.SeekPosition, stop *ab.SeekPosition) *cb.Envelope {
    43  	env, err := protoutil.CreateSignedEnvelope(cb.HeaderType_DELIVER_SEEK_INFO, r.channelID, r.signer, &ab.SeekInfo{
    44  		Start:    start,
    45  		Stop:     stop,
    46  		Behavior: ab.SeekInfo_BLOCK_UNTIL_READY,
    47  	}, 0, 0)
    48  	if err != nil {
    49  		panic(err)
    50  	}
    51  	return env
    52  }
    53  
    54  func (r *deliverClient) seekOldest() error {
    55  	return r.client.Send(r.seekHelper(oldest, maxStop))
    56  }
    57  
    58  func (r *deliverClient) seekNewest() error {
    59  	return r.client.Send(r.seekHelper(newest, maxStop))
    60  }
    61  
    62  func (r *deliverClient) seekSingle(blockNumber uint64) error {
    63  	specific := &ab.SeekPosition{Type: &ab.SeekPosition_Specified{Specified: &ab.SeekSpecified{Number: blockNumber}}}
    64  	return r.client.Send(r.seekHelper(specific, specific))
    65  }
    66  
    67  func (r *deliverClient) readUntilClose() {
    68  	for {
    69  		msg, err := r.client.Recv()
    70  		if err != nil {
    71  			fmt.Println("Error receiving:", err)
    72  			return
    73  		}
    74  
    75  		switch t := msg.Type.(type) {
    76  		case *ab.DeliverResponse_Status:
    77  			fmt.Println("Got status ", t)
    78  			return
    79  		case *ab.DeliverResponse_Block:
    80  			if !r.quiet {
    81  				fmt.Println("Received block: ")
    82  				err := protolator.DeepMarshalJSON(os.Stdout, t.Block)
    83  				if err != nil {
    84  					fmt.Printf("  Error pretty printing block: %s", err)
    85  				}
    86  			} else {
    87  				fmt.Println("Received block: ", t.Block.Header.Number)
    88  			}
    89  		}
    90  	}
    91  }
    92  
    93  func main() {
    94  	conf, err := localconfig.Load()
    95  	if err != nil {
    96  		fmt.Println("failed to load config:", err)
    97  		os.Exit(1)
    98  	}
    99  
   100  	// Load local MSP
   101  	mspConfig, err := msp.GetLocalMspConfig(conf.General.LocalMSPDir, conf.General.BCCSP, conf.General.LocalMSPID)
   102  	if err != nil {
   103  		fmt.Println("Failed to load MSP config:", err)
   104  		os.Exit(0)
   105  	}
   106  	err = mspmgmt.GetLocalMSP(factory.GetDefault()).Setup(mspConfig)
   107  	if err != nil { // Handle errors reading the config file
   108  		fmt.Println("Failed to initialize local MSP:", err)
   109  		os.Exit(0)
   110  	}
   111  
   112  	signer, err := mspmgmt.GetLocalMSP(factory.GetDefault()).GetDefaultSigningIdentity()
   113  	if err != nil {
   114  		fmt.Println("Failed to load local signing identity:", err)
   115  		os.Exit(0)
   116  	}
   117  
   118  	var channelID string
   119  	var serverAddr string
   120  	var seek int
   121  	var quiet bool
   122  
   123  	flag.StringVar(&serverAddr, "server", fmt.Sprintf("%s:%d", conf.General.ListenAddress, conf.General.ListenPort), "The RPC server to connect to.")
   124  	flag.StringVar(&channelID, "channelID", "mychannel", "The channel ID to deliver from.")
   125  	flag.BoolVar(&quiet, "quiet", false, "Only print the block number, will not attempt to print its block contents.")
   126  	flag.IntVar(&seek, "seek", -2, "Specify the range of requested blocks."+
   127  		"Acceptable values:"+
   128  		"-2 (or -1) to start from oldest (or newest) and keep at it indefinitely."+
   129  		"N >= 0 to fetch block N only.")
   130  	flag.Parse()
   131  
   132  	if seek < -2 {
   133  		fmt.Println("Wrong seek value.")
   134  		flag.PrintDefaults()
   135  	}
   136  
   137  	conn, err := grpc.Dial(serverAddr, grpc.WithInsecure())
   138  	if err != nil {
   139  		fmt.Println("Error connecting:", err)
   140  		return
   141  	}
   142  	client, err := ab.NewAtomicBroadcastClient(conn).Deliver(context.TODO())
   143  	if err != nil {
   144  		fmt.Println("Error connecting:", err)
   145  		return
   146  	}
   147  
   148  	s := newDeliverClient(client, channelID, signer, quiet)
   149  	switch seek {
   150  	case -2:
   151  		err = s.seekOldest()
   152  	case -1:
   153  		err = s.seekNewest()
   154  	default:
   155  		err = s.seekSingle(uint64(seek))
   156  	}
   157  
   158  	if err != nil {
   159  		fmt.Println("Received error:", err)
   160  	}
   161  
   162  	s.readUntilClose()
   163  }