func registerChaincodeSupport(chainname chaincode.ChainName, grpcServer *grpc.Server, secHelper crypto.Peer) { //get user mode userRunsCC := false if viper.GetString("chaincode.mode") == chaincode.DevModeUserRunsChaincode { userRunsCC = true } //get chaincode startup timeout tOut, err := strconv.Atoi(viper.GetString("chaincode.startuptimeout")) if err != nil { //what went wrong ? fmt.Printf("could not retrive timeout var...setting to 5secs\n") tOut = 5000 } ccStartupTimeout := time.Duration(tOut) * time.Millisecond ccSrv := chaincode.NewChaincodeSupport(chainname, peer.GetPeerEndpoint, userRunsCC, ccStartupTimeout, secHelper) //Now that chaincode is initialized, register all system chaincodes. system_chaincode.RegisterSysCCs() pb.RegisterChaincodeSupportServer(grpcServer, ccSrv) }
// Test deploy of a transaction. func TestExecuteDeploySysChaincode(t *testing.T) { 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 { grpclog.Fatalf("Failed to generate credentials %v", err) } opts = []grpc.ServerOption{grpc.Creds(creds)} } grpcServer := grpc.NewServer(opts...) viper.Set("peer.fileSystemPath", "/var/hyperledger/test/tmpdb") //lis, err := net.Listen("tcp", viper.GetString("peer.address")) //use a different address than what we usually use for "peer" //we override the peerAddress set in chaincode_support.go peerAddress := "0.0.0.0:40303" lis, err := net.Listen("tcp", peerAddress) if err != nil { t.Fail() t.Logf("Error starting peer listener %s", err) return } getPeerEndpoint := func() (*pb.PeerEndpoint, error) { return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil } ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond pb.RegisterChaincodeSupportServer(grpcServer, NewChaincodeSupport(DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil)) go grpcServer.Serve(lis) var ctxt = context.Background() system_chaincode.RegisterSysCCs() url := "github.com/hyperledger/fabric/core/system_chaincode/sample_syscc" args := []string{"greeting", "hello world"} cds := &pb.ChaincodeDeploymentSpec{ExecEnv: 1, ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "sample_syscc", Path: url}, CtorMsg: &pb.ChaincodeInput{Args: args}}} _, err = deploy2(ctxt, cds) chaincodeID := cds.ChaincodeSpec.ChaincodeID.Name if err != nil { GetChain(DefaultChain).Stop(ctxt, cds) closeListenerAndSleep(lis) t.Fail() t.Logf("Error deploying <%s>: %s", chaincodeID, err) return } GetChain(DefaultChain).Stop(ctxt, cds) closeListenerAndSleep(lis) }
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) // Disable validity system chaincode in dev mode. Also if security is enabled, // in membersrvc.yaml, manually set pki.validity-period.update to false to prevent // membersrvc from calling validity system chaincode -- though no harm otherwise viper.Set("ledger.blockchain.deploy-system-chaincode", "false") viper.Set("validator.validity-period.verification", "false") } if err := peer.CacheConfiguration(); err != nil { return err } //register all system chaincodes. This just registers chaincodes, they must be //still be deployed and launched system_chaincode.RegisterSysCCs() 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.Info("Security enabled status: %t", core.SecurityEnabled()) logger.Info("Privacy enabled status: %t", viper.GetBool("security.privacy")) var opts []grpc.ServerOption if peer.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...) secHelper, err := getSecHelper() if err != nil { return err } secHelperFunc := func() crypto.Peer { return secHelper } registerChaincodeSupport(chaincode.DefaultChain, grpcServer, secHelper) var peerServer *peer.PeerImpl //create the peerServer.... if peer.ValidatorEnabled() { logger.Debug("Running as validating peer - making genesis block if needed") makeGenesisError := genesis.MakeGenesis() if makeGenesisError != nil { return makeGenesisError } logger.Debug("Running as validating peer - installing consensus %s", viper.GetString("peer.validator.consensus")) peerServer, err = peer.NewPeerWithEngine(secHelperFunc, helper.GetEngine) } else { logger.Debug("Running as non-validating peer") peerServer, err = peer.NewPeerWithHandler(secHelperFunc, peer.NewPeerHandler) } if err != nil { logger.Fatalf("Failed creating new peer with handler %v", err) return err } // Register the Peer server //pb.RegisterPeerServer(grpcServer, openchain.NewPeer()) pb.RegisterPeerServer(grpcServer, peerServer) // Register the Admin server pb.RegisterAdminServer(grpcServer, core.NewAdminServer()) // Register Devops server serverDevops := core.NewDevopsServer(peerServer) pb.RegisterDevopsServer(grpcServer, serverDevops) // Register the ServerOpenchain server serverOpenchain, err := rest.NewOpenchainServerWithPeerInfo(peerServer) if err != nil { err = fmt.Errorf("Error creating OpenchainServer: %s", err) return err } pb.RegisterOpenchainServer(grpcServer, serverOpenchain) // Create and register the REST service if configured if viper.GetBool("rest.enabled") { go rest.StartOpenchainRESTServer(serverOpenchain, serverDevops) } rootNode, err := core.GetRootNode() if err != nil { grpclog.Fatalf("Failed to get peer.discovery.rootnode valey: %s", err) } logger.Info("Starting peer with id=%s, network id=%s, address=%s, discovery.rootnode=%s, validator=%v", peerEndpoint.ID, viper.GetString("peer.networkId"), peerEndpoint.Address, rootNode, peer.ValidatorEnabled()) // Start the grpc server. Done in a goroutine so we can deploy the // genesis block if needed. serve := make(chan error) 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.Info(fmt.Sprintf("Starting profiling server with listenAddress = %s", profileListenAddress)) if profileErr := http.ListenAndServe(profileListenAddress, nil); profileErr != nil { logger.Error("Error starting profiler: %s", profileErr) } }() } // Block until grpc server exits return <-serve }