Merge "FAB-2767 expose chaincode timeout as a property"

core/chaincode/chaincode_support.go

@@ -168,6 +168,17 @@ func NewChaincodeSupport(getPeerEndpoint func() (*pb.PeerEndpoint, error), userr
  theChaincodeSupport.keepalive = time.Duration(t) * time.Second
  }
 
+ //default chaincode execute timeout is 30000ms (30 secs)
+ execto := 30000
+ if eto := viper.GetInt("chaincode.executetimeout"); eto <= 1000 {
+ chaincodeLogger.Errorf("Invalid execute timeout value %d (should be at least 1000ms) defaulting to %d ms", eto, execto)
+ } else {
+ chaincodeLogger.Debugf("Setting execute timeout value to %d ms", eto)
+ execto = eto
+ }
+
+ theChaincodeSupport.executetimeout = time.Duration(execto) * time.Millisecond
+
  viper.SetEnvPrefix("CORE")
  viper.AutomaticEnv()
  replacer := strings.NewReplacer(".", "_")
@@ -208,6 +219,7 @@ type ChaincodeSupport struct {
  keepalive time.Duration
  chaincodeLogLevel string
  logFormat string
+ executetimeout time.Duration
 }
 
 // DuplicateChaincodeHandlerError returned if attempt to register same chaincodeID while a stream already exists.

core/chaincode/exectransaction.go

@@ -19,7 +19,6 @@ package chaincode
 import (
  "errors"
  "fmt"
- "time"
 
  "github.com/golang/protobuf/proto"
  "golang.org/x/net/context"
@@ -57,9 +56,6 @@ func Execute(ctxt context.Context, cccid *ccprovider.CCContext, spec interface{}
  return nil, nil, fmt.Errorf("Failed to stablish stream to container %s", chaincode)
  }
 
- // TODO: Need to comment next line and uncomment call to getTimeout, when transaction blocks are being created
- timeout := time.Duration(30000) * time.Millisecond
-
  if err != nil {
  return nil, nil, fmt.Errorf("Failed to retrieve chaincode spec(%s)", err)
  }
@@ -70,7 +66,7 @@ func Execute(ctxt context.Context, cccid *ccprovider.CCContext, spec interface{}
  return nil, nil, fmt.Errorf("Failed to transaction message(%s)", err)
  }
 
- resp, err := theChaincodeSupport.Execute(ctxt, cccid, ccMsg, timeout)
+ resp, err := theChaincodeSupport.Execute(ctxt, cccid, ccMsg, theChaincodeSupport.executetimeout)
  if err != nil {
  // Rollback transaction
  return nil, nil, fmt.Errorf("Failed to execute transaction (%s)", err)

examples/chaincode/go/sleeper/sleeper.go

@@ -0,0 +1,124 @@
+/*
+Copyright IBM Corp. 2016 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+// Sleeper chaincode sleeps and works with one state variable
+// Init - 1 param, a sleep time in millisecs
+// Invoke - 4 or 3 params, "put" or "get", value to set and sleep time in millisecs
+//
+// Sleeper can be used to test the "chaincode.executetimeout" property
+
+import (
+ "fmt"
+ "strconv"
+ "time"
+
+ "github.com/hyperledger/fabric/core/chaincode/shim"
+ pb "github.com/hyperledger/fabric/protos/peer"
+)
+
+// SleeperChaincode example simple Chaincode implementation
+type SleeperChaincode struct {
+}
+
+func (t *SleeperChaincode) sleep(sleepTime string) {
+ st, _ := strconv.Atoi(sleepTime)
+ if st >= 0 {
+ time.Sleep(time.Duration(st) * time.Millisecond)
+ }
+}
+
+// Init initializes chaincode...all it does is sleep a bi
+func (t *SleeperChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
+ args := stub.GetStringArgs()
+
+ if len(args) != 1 {
+ return shim.Error("Incorrect number of arguments. Expecting 1")
+ }
+
+ sleepTime := args[0]
+
+ t.sleep(sleepTime)
+
+ return shim.Success(nil)
+}
+
+// Invoke sets key/value and sleeps a bit
+func (t *SleeperChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
+ function, args := stub.GetFunctionAndParameters()
+ if function == "put" {
+ if len(args) != 3 {
+ return shim.Error("Incorrect number of arguments. Expecting 3")
+ }
+
+ // Make payment of X units from A to B
+ return t.invoke(stub, args)
+ } else if function == "get" {
+ if len(args) != 2 {
+ return shim.Error("Incorrect number of arguments. Expecting 2")
+ }
+
+ // the old "Query" is now implemtned in invoke
+ return t.query(stub, args)
+ }
+
+ return shim.Error("Invalid invoke function name. Expecting \"put\" or \"get\"")
+}
+
+// Transaction makes payment of X units from A to B
+func (t *SleeperChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
+ // set state
+ key := args[0]
+ val := args[1]
+
+ err := stub.PutState(key, []byte(val))
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ sleepTime := args[2]
+
+ //sleep for a bit
+ t.sleep(sleepTime)
+
+ return shim.Success([]byte("OK"))
+}
+
+// query callback representing the query of a chaincode
+func (t *SleeperChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
+ key := args[0]
+
+ // Get the state from the ledger
+ val, err := stub.GetState(key)
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ sleepTime := args[1]
+
+ //sleep for a bit
+ t.sleep(sleepTime)
+
+ return shim.Success(val)
+}
+
+func main() {
+ err := shim.Start(new(SleeperChaincode))
+ if err != nil {
+ fmt.Printf("Error starting Sleeper chaincode: %s", err)
+ }
+}

peer/core.yaml

@@ -323,6 +323,11 @@ chaincode:
  # to come through. 1sec should be plenty for chaincode unit tests
  startuptimeout: 300000
 
+ # timeout in millisecs for invokes and initialize commands
+ # this timeout is used by all chaincodes in all the channels including
+ # system chaincodes. Default is 30000ms (30 seconds)
+ executetimeout: 30000
+
  #timeout in millisecs for deploying chaincode from a remote repository.
  deploytimeout: 30000