// GetBlockchainSize returns the current size of the blockchain func (h *Helper) GetBlockchainSize() (uint64, error) { ledger, err := ledger.GetLedger() if err != nil { return 0, fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.GetBlockchainSize(), nil }
func (i *Noops) getBlockData() (*pb.Block, *statemgmt.StateDelta, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, nil, fmt.Errorf("Fail to get the ledger: %v", err) } blockHeight := ledger.GetBlockchainSize() if logger.IsEnabledFor(logging.DEBUG) { logger.Debug("Preparing to broadcast with block number %v", blockHeight) } block, err := ledger.GetBlockByNumber(blockHeight - 1) if nil != err { return nil, nil, err } //delta, err := ledger.GetStateDeltaBytes(blockHeight) delta, err := ledger.GetStateDelta(blockHeight - 1) if nil != err { return nil, nil, err } if logger.IsEnabledFor(logging.DEBUG) { logger.Debug("Got the delta state of block number %v", blockHeight) } return block, delta, nil }
func TestGenesis(t *testing.T) { //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:50303" lis, err := net.Listen("tcp", peerAddress) if err != nil { t.Fail() t.Logf("Error starting peer listener %s", err) return } 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...) getPeerEndpoint := func() (*protos.PeerEndpoint, error) { return &protos.PeerEndpoint{ID: &protos.PeerID{Name: "testpeer"}, Address: peerAddress}, nil } ccStartupTimeout := time.Duration(30000) * time.Millisecond protos.RegisterChaincodeSupportServer(grpcServer, chaincode.NewChaincodeSupport(chaincode.DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil)) go grpcServer.Serve(lis) ledger := ledger.InitTestLedger(t) if ledger.GetBlockchainSize() != 0 { t.Fatalf("Expected blockchain size of 0, but got %d", ledger.GetBlockchainSize()) } makeGenesisErr := MakeGenesis() if makeGenesisErr != nil { t.Fatalf("Error creating genesis block, %s", makeGenesisErr) } if ledger.GetBlockchainSize() != 1 { t.Fatalf("Expected blockchain size of 1, but got %d", ledger.GetBlockchainSize()) } }
// CommitTxBatch gets invoked when the current transaction-batch needs // to be committed. This function returns successfully iff the // transactions details and state changes (that may have happened // during execution of this transaction-batch) have been committed to // permanent storage. func (h *Helper) CommitTxBatch(id interface{}, metadata []byte) (*pb.Block, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger: %v", err) } // TODO fix this one the ledger has been fixed to implement if err := ledger.CommitTxBatch(id, h.curBatch, nil, metadata); err != nil { return nil, fmt.Errorf("Failed to commit transaction to the ledger: %v", err) } size := ledger.GetBlockchainSize() h.curBatch = nil // TODO, remove after issue 579 block, err := ledger.GetBlockByNumber(size - 1) if err != nil { return nil, fmt.Errorf("Failed to get the block at the head of the chain: %v", err) } return block, nil }
func (i *Noops) notifyBlockAdded() error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Fail to get the ledger: %v", err) } // TODO: Broadcast SYNC_BLOCK_ADDED to connected NVPs // VPs already know about this newly added block since they participate // in the execution. That is, they can compare their current block with // the network block // For now, send to everyone until broadcast has better discrimination blockHeight := ledger.GetBlockchainSize() logger.Debug("Preparing to broadcast with block number %v", blockHeight) block, err := ledger.GetBlockByNumber(blockHeight - 1) if nil != err { return err } //delta, err := ledger.GetStateDeltaBytes(blockHeight) delta, err := ledger.GetStateDelta(blockHeight - 1) if nil != err { return err } logger.Debug("Got the delta state of block number %v", blockHeight) data, err := proto.Marshal(&pb.BlockState{Block: block, StateDelta: delta.Marshal()}) if err != nil { return fmt.Errorf("Fail to marshall BlockState structure: %v", err) } logger.Debug("Broadcasting OpenchainMessage_SYNC_BLOCK_ADDED") msg := &pb.OpenchainMessage{Type: pb.OpenchainMessage_SYNC_BLOCK_ADDED, Payload: data, Timestamp: util.CreateUtcTimestamp()} if errs := i.cpi.Broadcast(msg); nil != errs { return fmt.Errorf("Failed to broadcast with errors: %v", errs) } return nil }
// MakeGenesis creates the genesis block based on configuration in openchain.yaml // and adds it to the blockchain. func MakeGenesis() error { once.Do(func() { ledger, err := ledger.GetLedger() if err != nil { makeGenesisError = err return } if ledger.GetBlockchainSize() > 0 { // genesis block already exists return } genesisLogger.Info("Creating genesis block.") ledger.BeginTxBatch(0) var genesisTransactions []*protos.Transaction //We are disabling the validity period deployment for now, we shouldn't even allow it if it's enabled in the configuration allowDeployValidityPeriod := false if deploySystemChaincodeEnabled() && allowDeployValidityPeriod { vpTransaction, deployErr := deployUpdateValidityPeriodChaincode() if deployErr != nil { genesisLogger.Error("Error deploying validity period system chaincode for genesis block.", deployErr) makeGenesisError = deployErr return } genesisTransactions = append(genesisTransactions, vpTransaction) } genesis := viper.GetStringMap("ledger.blockchain.genesisBlock") if genesis == nil { genesisLogger.Info("No genesis block chaincodes defined.") } else { chaincodes, chaincodesOK := genesis["chaincode"].([]interface{}) if !chaincodesOK { genesisLogger.Info("No genesis block chaincodes defined.") ledger.CommitTxBatch(0, genesisTransactions, nil, nil) return } genesisLogger.Debug("Genesis chaincodes are %s", chaincodes) for i := 0; i < len(chaincodes); i++ { genesisLogger.Debug("Chaincode %d is %s", i, chaincodes[i]) chaincodeMap, chaincodeMapOK := chaincodes[i].(map[interface{}]interface{}) if !chaincodeMapOK { genesisLogger.Error("Invalid chaincode defined in genesis configuration:", chaincodes[i]) makeGenesisError = fmt.Errorf("Invalid chaincode defined in genesis configuration: %s", chaincodes[i]) return } path, pathOK := chaincodeMap["path"].(string) if !pathOK { genesisLogger.Error("Invalid chaincode URL defined in genesis configuration:", chaincodeMap["path"]) makeGenesisError = fmt.Errorf("Invalid chaincode URL defined in genesis configuration: %s", chaincodeMap["path"]) return } chaincodeType, chaincodeTypeOK := chaincodeMap["type"].(string) if !chaincodeTypeOK { genesisLogger.Error("Invalid chaincode type defined in genesis configuration:", chaincodeMap["type"]) makeGenesisError = fmt.Errorf("Invalid chaincode type defined in genesis configuration: %s", chaincodeMap["type"]) return } chaincodeID := &protos.ChaincodeID{Path: path, Name: ""} genesisLogger.Debug("Genesis chaincodeID %s", chaincodeID) genesisLogger.Debug("Genesis chaincode type %s", chaincodeType) constructorMap, constructorMapOK := chaincodeMap["constructor"].(map[interface{}]interface{}) if !constructorMapOK { genesisLogger.Error("Invalid chaincode constructor defined in genesis configuration:", chaincodeMap["constructor"]) makeGenesisError = fmt.Errorf("Invalid chaincode constructor defined in genesis configuration: %s", chaincodeMap["constructor"]) return } var spec protos.ChaincodeSpec if constructorMap == nil { genesisLogger.Debug("Genesis chaincode has no constructor.") spec = protos.ChaincodeSpec{Type: protos.ChaincodeSpec_Type(protos.ChaincodeSpec_Type_value[chaincodeType]), ChaincodeID: chaincodeID} } else { ctorFunc, ctorFuncOK := constructorMap["func"].(string) if !ctorFuncOK { genesisLogger.Error("Invalid chaincode constructor function defined in genesis configuration:", constructorMap["func"]) makeGenesisError = fmt.Errorf("Invalid chaincode constructor function args defined in genesis configuration: %s", constructorMap["func"]) return } ctorArgs, ctorArgsOK := constructorMap["args"].([]interface{}) if !ctorArgsOK { genesisLogger.Error("Invalid chaincode constructor args defined in genesis configuration:", constructorMap["args"]) makeGenesisError = fmt.Errorf("Invalid chaincode constructor args defined in genesis configuration: %s", constructorMap["args"]) return } genesisLogger.Debug("Genesis chaincode constructor func %s", ctorFunc) genesisLogger.Debug("Genesis chaincode constructor args %s", ctorArgs) var ctorArgsStringArray []string for j := 0; j < len(ctorArgs); j++ { ctorArgsStringArray = append(ctorArgsStringArray, ctorArgs[j].(string)) } spec = protos.ChaincodeSpec{Type: protos.ChaincodeSpec_Type(protos.ChaincodeSpec_Type_value[chaincodeType]), ChaincodeID: chaincodeID, CtorMsg: &protos.ChaincodeInput{Function: ctorFunc, Args: ctorArgsStringArray}} } transaction, _, deployErr := DeployLocal(context.Background(), &spec) if deployErr != nil { genesisLogger.Error("Error deploying chaincode for genesis block.", deployErr) makeGenesisError = deployErr return } genesisTransactions = append(genesisTransactions, transaction) } //for } //else genesisLogger.Info("Adding %d system chaincodes to the genesis block.", len(genesisTransactions)) ledger.CommitTxBatch(0, genesisTransactions, nil, nil) }) return makeGenesisError }