//initialize peer and start up. If security==enabled, login as vp func initPeer(chainID string) (net.Listener, error) { //start clean finitPeer(nil) var opts []grpc.ServerOption if viper.GetBool("peer.tls.enabled") { creds, err := credentials.NewServerTLSFromFile(viper.GetString("peer.tls.cert.file"), viper.GetString("peer.tls.key.file")) if err != nil { return nil, fmt.Errorf("Failed to generate credentials %v", err) } opts = []grpc.ServerOption{grpc.Creds(creds)} } grpcServer := grpc.NewServer(opts...) viper.Set("peer.fileSystemPath", filepath.Join(os.TempDir(), "hyperledger", "production")) peerAddress, err := peer.GetLocalAddress() if err != nil { return nil, fmt.Errorf("Error obtaining peer address: %s", err) } lis, err := net.Listen("tcp", peerAddress) if err != nil { return nil, fmt.Errorf("Error starting peer listener %s", err) } //initialize ledger peer.MockInitialize() getPeerEndpoint := func() (*pb.PeerEndpoint, error) { return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil } // Install security object for peer if viper.GetBool("security.enabled") { //TODO: integrate new crypto / idp securityLevel := viper.GetInt("security.level") hashAlgorithm := viper.GetString("security.hashAlgorithm") primitives.SetSecurityLevel(hashAlgorithm, securityLevel) } else { // the primitives need to be instantiated no matter what. Otherwise // the escc code won't have a hash algorithm available to hash the proposal primitives.SetSecurityLevel("SHA2", 256) } ccStartupTimeout := time.Duration(30000) * time.Millisecond pb.RegisterChaincodeSupportServer(grpcServer, chaincode.NewChaincodeSupport(getPeerEndpoint, false, ccStartupTimeout)) chaincode.RegisterSysCCs() if err = peer.MockCreateChain(chainID); err != nil { closeListenerAndSleep(lis) return nil, err } chaincode.DeploySysCCs(chainID) go grpcServer.Serve(lis) return lis, nil }
func serve(args []string) error { // Parameter overrides must be processed before any paramaters are // cached. Failures to cache cause the server to terminate immediately. if chaincodeDevMode { logger.Info("Running in chaincode development mode") logger.Info("Set consensus to NOOPS and user starts chaincode") logger.Info("Disable loading validity system chaincode") viper.Set("peer.validator.enabled", "true") viper.Set("peer.validator.consensus", "noops") viper.Set("chaincode.mode", chaincode.DevModeUserRunsChaincode) } if err := peer.CacheConfiguration(); err != nil { return err } peerEndpoint, err := peer.GetPeerEndpoint() if err != nil { err = fmt.Errorf("Failed to get Peer Endpoint: %s", err) return err } listenAddr := viper.GetString("peer.listenAddress") if "" == listenAddr { logger.Debug("Listen address not specified, using peer endpoint address") listenAddr = peerEndpoint.Address } lis, err := net.Listen("tcp", listenAddr) if err != nil { grpclog.Fatalf("Failed to listen: %v", err) } ehubLis, ehubGrpcServer, err := createEventHubServer() if err != nil { grpclog.Fatalf("Failed to create ehub server: %v", err) } logger.Infof("Security enabled status: %t", core.SecurityEnabled()) if viper.GetBool("security.privacy") { if core.SecurityEnabled() { logger.Infof("Privacy enabled status: true") } else { panic(errors.New("Privacy cannot be enabled as requested because security is disabled")) } } else { logger.Infof("Privacy enabled status: false") } var opts []grpc.ServerOption if comm.TLSEnabled() { creds, err := credentials.NewServerTLSFromFile(viper.GetString("peer.tls.cert.file"), viper.GetString("peer.tls.key.file")) if err != nil { grpclog.Fatalf("Failed to generate credentials %v", err) } opts = []grpc.ServerOption{grpc.Creds(creds)} } grpcServer := grpc.NewServer(opts...) registerChaincodeSupport(grpcServer) logger.Debugf("Running peer") // Register the Admin server pb.RegisterAdminServer(grpcServer, core.NewAdminServer()) // Register the Endorser server serverEndorser := endorser.NewEndorserServer() pb.RegisterEndorserServer(grpcServer, serverEndorser) // Initialize gossip component bootstrap := viper.GetStringSlice("peer.gossip.bootstrap") service.InitGossipService(peerEndpoint.Address, grpcServer, bootstrap...) defer service.GetGossipService().Stop() //initialize the env for chainless startup initChainless() // Begin startup of default chain if peerDefaultChain { chainID := util.GetTestChainID() block, err := pbutils.MakeConfigurationBlock(chainID) if nil != err { panic(fmt.Sprintf("Unable to create genesis block for [%s] due to [%s]", chainID, err)) } //this creates block and calls JoinChannel on gossip service if err = peer.CreateChainFromBlock(block); err != nil { panic(fmt.Sprintf("Unable to create chain block for [%s] due to [%s]", chainID, err)) } chaincode.DeploySysCCs(chainID) logger.Infof("Deployed system chaincodes on %s", chainID) commit := peer.GetCommitter(chainID) if commit == nil { panic(fmt.Sprintf("Unable to get committer for [%s]", chainID)) } //this shoul not need the chainID. Delivery should be //split up into network part and chain part. This should //only init the network part...TBD, part of Join work deliverService := noopssinglechain.NewDeliverService(chainID) deliverService.Start(commit) defer noopssinglechain.StopDeliveryService(deliverService) } logger.Infof("Starting peer with ID=%s, network ID=%s, address=%s, rootnodes=%v, validator=%v", peerEndpoint.ID, viper.GetString("peer.networkId"), peerEndpoint.Address, viper.GetString("peer.discovery.rootnode"), peer.ValidatorEnabled()) // Start the grpc server. Done in a goroutine so we can deploy the // genesis block if needed. serve := make(chan error) sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) go func() { sig := <-sigs fmt.Println() fmt.Println(sig) serve <- nil }() go func() { var grpcErr error if grpcErr = grpcServer.Serve(lis); grpcErr != nil { grpcErr = fmt.Errorf("grpc server exited with error: %s", grpcErr) } else { logger.Info("grpc server exited") } serve <- grpcErr }() if err := writePid(viper.GetString("peer.fileSystemPath")+"/peer.pid", os.Getpid()); err != nil { return err } // Start the event hub server if ehubGrpcServer != nil && ehubLis != nil { go ehubGrpcServer.Serve(ehubLis) } if viper.GetBool("peer.profile.enabled") { go func() { profileListenAddress := viper.GetString("peer.profile.listenAddress") logger.Infof("Starting profiling server with listenAddress = %s", profileListenAddress) if profileErr := http.ListenAndServe(profileListenAddress, nil); profileErr != nil { logger.Errorf("Error starting profiler: %s", profileErr) } }() } // sets the logging level for the 'error' module to the default value from // core.yaml. it can also be updated dynamically using // "peer logging setlevel error <log-level>" common.SetErrorLoggingLevel() // Block until grpc server exits return <-serve }