[FAB-9647] Rename ContainerRuntime and cleanup

Fix some doc comments, remove unused member data, config code mistakenly
left behind.

Change-Id: I8dfe358e8e04aefbc6d3ba91a472ce456c321492
Signed-off-by: Matthew Sykes <sykesmat@us.ibm.com>

Author: sykesm

core/chaincode/chaincode_support.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/hyperledger/fabric/core/chaincode/accesscontrol"
 	"github.com/hyperledger/fabric/core/common/ccprovider"
 	"github.com/hyperledger/fabric/core/common/sysccprovider"
 	"github.com/hyperledger/fabric/core/container"
@@ -21,54 +20,48 @@ import (
 	"golang.org/x/net/context"
 )
 
-// CertGenerator generate client certificates for chaincode
-type CertGenerator interface {
-	// Generate returns a certificate and private key and associates
-	// the hash of the certificates with the given chaincode name
-	Generate(ccName string) (*accesscontrol.CertAndPrivKeyPair, error)
-}
-
 // Runtime is used to manage chaincode runtime instances.
 type Runtime interface {
 	Start(ctxt context.Context, cccid *ccprovider.CCContext, cds *pb.ChaincodeDeploymentSpec) error
 	Stop(ctxt context.Context, cccid *ccprovider.CCContext, cds *pb.ChaincodeDeploymentSpec) error
 }
 
-// PackageProvider is responsible for getting the chaincode package from
-// the filesystem.
-type PackageProvider interface {
-	GetChaincode(ccname string, ccversion string) (ccprovider.CCPackage, error)
+// ChaincodeSupport responsible for providing interfacing with chaincodes from the Peer.
+type ChaincodeSupport struct {
+	Keepalive       time.Duration
+	ExecuteTimeout  time.Duration
+	UserRunsCC      bool
+	Runtime         Runtime
+	ACLProvider     ACLProvider
+	HandlerRegistry *HandlerRegistry
+	Launcher        *Launcher
+	sccp            sysccprovider.SystemChaincodeProvider
 }
 
 // NewChaincodeSupport creates a new ChaincodeSupport instance.
 func NewChaincodeSupport(
 	config *Config,
 	peerAddress string,
-	userrunsCC bool,
+	userRunsCC bool,
 	caCert []byte,
 	certGenerator CertGenerator,
 	packageProvider PackageProvider,
 	aclProvider ACLProvider,
 ) *ChaincodeSupport {
 	cs := &ChaincodeSupport{
-		caCert:           caCert,
-		peerNetworkID:    config.PeerNetworkID,
-		peerID:           config.PeerID,
-		userRunsCC:       userrunsCC,
-		ccStartupTimeout: config.StartupTimeout,
-		keepalive:        config.Keepalive,
-		executetimeout:   config.ExecuteTimeout,
-		HandlerRegistry:  NewHandlerRegistry(userrunsCC),
-		PackageProvider:  packageProvider,
-		ACLProvider:      aclProvider,
+		UserRunsCC:      userRunsCC,
+		Keepalive:       config.Keepalive,
+		ExecuteTimeout:  config.ExecuteTimeout,
+		HandlerRegistry: NewHandlerRegistry(userRunsCC),
+		ACLProvider:     aclProvider,
 	}
 
 	// Keep TestQueries working
 	if !config.TLSEnabled {
 		certGenerator = nil
 	}
 
-	cs.ContainerRuntime = &ContainerRuntime{
+	cs.Runtime = &ContainerRuntime{
 		CertGenerator: certGenerator,
 		Processor:     ProcessFunc(container.VMCProcess),
 		CACert:        caCert,
@@ -83,34 +76,16 @@ func NewChaincodeSupport(
 	}
 
 	cs.Launcher = &Launcher{
-		Runtime:         cs.ContainerRuntime,
+		Runtime:         cs.Runtime,
 		Registry:        cs.HandlerRegistry,
-		PackageProvider: cs.PackageProvider,
+		PackageProvider: packageProvider,
 		Lifecycle:       &Lifecycle{Executor: cs},
 		StartupTimeout:  config.StartupTimeout,
 	}
 
 	return cs
 }
 
-// ChaincodeSupport responsible for providing interfacing with chaincodes from the Peer.
-type ChaincodeSupport struct {
-	caCert           []byte
-	peerAddress      string
-	ccStartupTimeout time.Duration
-	peerNetworkID    string
-	peerID           string
-	keepalive        time.Duration
-	executetimeout   time.Duration
-	userRunsCC       bool
-	ContainerRuntime Runtime
-	PackageProvider  PackageProvider
-	ACLProvider      ACLProvider
-	HandlerRegistry  *HandlerRegistry
-	Launcher         *Launcher
-	sccp             sysccprovider.SystemChaincodeProvider
-}
-
 // SetSysCCProvider is a bit of a hack to make a latent dependency of ChaincodeSupport
 // be an explicit dependency.  Because the chaincode support must be registered before
 // the sysccprovider implementation can be created, we cannot make the sccp part of the
@@ -127,7 +102,7 @@ func (cs *ChaincodeSupport) Launch(ctx context.Context, cccid *ccprovider.CCCont
 	}
 
 	// TODO: There has to be a better way to do this...
-	if cs.userRunsCC && !cccid.Syscc {
+	if cs.UserRunsCC && !cccid.Syscc {
 		chaincodeLogger.Error(
 			"You are attempting to perform an action other than Deploy on Chaincode that is not ready and you are in developer mode. Did you forget to Deploy your chaincode?",
 		)
@@ -146,7 +121,7 @@ func (cs *ChaincodeSupport) Stop(ctx context.Context, cccid *ccprovider.CCContex
 	cname := cccid.GetCanonicalName()
 	defer cs.HandlerRegistry.Deregister(cname)
 
-	err := cs.ContainerRuntime.Stop(ctx, cccid, cds)
+	err := cs.Runtime.Stop(ctx, cccid, cds)
 	if err != nil {
 		return err
 	}
@@ -179,23 +154,24 @@ func createCCMessage(messageType pb.ChaincodeMessage_Type, cid string, txid stri
 	return ccmsg, nil
 }
 
-// execute executes a transaction and waits for it to complete until a timeout value.
-func (cs *ChaincodeSupport) execute(ctxt context.Context, cccid *ccprovider.CCContext, msg *pb.ChaincodeMessage, timeout time.Duration) (*pb.ChaincodeMessage, error) {
-	cname := cccid.GetCanonicalName()
-	chaincodeLogger.Debugf("canonical name: %s", cname)
-
-	handler := cs.HandlerRegistry.Handler(cname)
-	if handler == nil {
-		chaincodeLogger.Debugf("chaincode is not running: %s", cname)
-		return nil, errors.Errorf("unable to invoke chaincode %s", cname)
+// ExecuteChaincode invokes chaincode with the provided arguments.
+func (cs *ChaincodeSupport) ExecuteChaincode(ctxt context.Context, cccid *ccprovider.CCContext, args [][]byte) (*pb.Response, *pb.ChaincodeEvent, error) {
+	invocationSpec := &pb.ChaincodeInvocationSpec{
+		ChaincodeSpec: &pb.ChaincodeSpec{
+			Type:        pb.ChaincodeSpec_GOLANG,
+			ChaincodeId: &pb.ChaincodeID{Name: cccid.Name},
+			Input:       &pb.ChaincodeInput{Args: args},
+		},
 	}
 
-	ccresp, err := handler.Execute(ctxt, cccid, msg, timeout)
+	res, ccevent, err := cs.ExecuteSpec(ctxt, cccid, invocationSpec)
 	if err != nil {
-		return nil, errors.WithMessage(err, fmt.Sprintf("error sending"))
+		err = errors.WithMessage(err, "error invoking chaincode")
+		chaincodeLogger.Errorf("%+v", err)
+		return nil, nil, err
 	}
 
-	return ccresp, nil
+	return res, ccevent, err
 }
 
 //Execute - execute proposal, return original response of chaincode
@@ -222,7 +198,7 @@ func (cs *ChaincodeSupport) ExecuteSpec(ctxt context.Context, cccid *ccprovider.
 		return nil, nil, errors.WithMessage(err, "failed to create chaincode message")
 	}
 
-	resp, err := cs.execute(ctxt, cccid, ccMsg, cs.executetimeout)
+	resp, err := cs.execute(ctxt, cccid, ccMsg)
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "failed to execute transaction %s", cccid.TxID)
 	}
@@ -252,22 +228,21 @@ func (cs *ChaincodeSupport) ExecuteSpec(ctxt context.Context, cccid *ccprovider.
 	}
 }
 
-// ExecuteChaincode invokes chaincode with the provided arguments.
-func (cs *ChaincodeSupport) ExecuteChaincode(ctxt context.Context, cccid *ccprovider.CCContext, args [][]byte) (*pb.Response, *pb.ChaincodeEvent, error) {
-	invocationSpec := &pb.ChaincodeInvocationSpec{
-		ChaincodeSpec: &pb.ChaincodeSpec{
-			Type:        pb.ChaincodeSpec_GOLANG,
-			ChaincodeId: &pb.ChaincodeID{Name: cccid.Name},
-			Input:       &pb.ChaincodeInput{Args: args},
-		},
+// execute executes a transaction and waits for it to complete until a timeout value.
+func (cs *ChaincodeSupport) execute(ctxt context.Context, cccid *ccprovider.CCContext, msg *pb.ChaincodeMessage) (*pb.ChaincodeMessage, error) {
+	cname := cccid.GetCanonicalName()
+	chaincodeLogger.Debugf("canonical name: %s", cname)
+
+	handler := cs.HandlerRegistry.Handler(cname)
+	if handler == nil {
+		chaincodeLogger.Debugf("chaincode is not running: %s", cname)
+		return nil, errors.Errorf("unable to invoke chaincode %s", cname)
 	}
 
-	res, ccevent, err := cs.ExecuteSpec(ctxt, cccid, invocationSpec)
+	ccresp, err := handler.Execute(ctxt, cccid, msg, cs.ExecuteTimeout)
 	if err != nil {
-		err = errors.WithMessage(err, "error invoking chaincode")
-		chaincodeLogger.Errorf("%+v", err)
-		return nil, nil, err
+		return nil, errors.WithMessage(err, fmt.Sprintf("error sending"))
 	}
 
-	return res, ccevent, err
+	return ccresp, nil
 }

core/chaincode/chaincode_support_test.go

@@ -1005,7 +1005,7 @@ func getLaunchConfigs(t *testing.T, cr *ContainerRuntime) {
 }
 
 //success case
-func TestLaunchAndWaitSuccess(t *testing.T) {
+func TestStartAndWaitSuccess(t *testing.T) {
 	handlerRegistry := NewHandlerRegistry(false)
 	fakeRuntime := &mock.Runtime{}
 	fakeRuntime.StartStub = func(_ context.Context, _ *ccprovider.CCContext, _ *pb.ChaincodeDeploymentSpec) error {
@@ -1024,14 +1024,14 @@ func TestLaunchAndWaitSuccess(t *testing.T) {
 	cccid := ccprovider.NewCCContext("testchannel", "testcc", "0", "landwtimertest_txid", false, nil, nil)
 
 	//actual test - everythings good
-	err := launcher.launchAndWaitForReady(context.Background(), cccid, cds)
+	err := launcher.startAndWaitForReady(context.Background(), cccid, cds)
 	if err != nil {
 		t.Fatalf("expected success but failed with error %s", err)
 	}
 }
 
 //test timeout error
-func TestLaunchAndWaitTimeout(t *testing.T) {
+func TestStartAndWaitTimeout(t *testing.T) {
 	fakeRuntime := &mock.Runtime{}
 	fakeRuntime.StartStub = func(_ context.Context, _ *ccprovider.CCContext, _ *pb.ChaincodeDeploymentSpec) error {
 		time.Sleep(time.Second)
@@ -1049,14 +1049,14 @@ func TestLaunchAndWaitTimeout(t *testing.T) {
 	cccid := ccprovider.NewCCContext("testchannel", "testcc", "0", "landwtimertest_txid", false, nil, nil)
 
 	//the actual test - timeout 1000 > 500
-	err := launcher.launchAndWaitForReady(context.Background(), cccid, cds)
+	err := launcher.startAndWaitForReady(context.Background(), cccid, cds)
 	if err == nil {
 		t.Fatalf("expected error but succeeded")
 	}
 }
 
 //test container return error
-func TestLaunchAndWaitLaunchError(t *testing.T) {
+func TestStartAndWaitLaunchError(t *testing.T) {
 	fakeRuntime := &mock.Runtime{}
 	fakeRuntime.StartStub = func(_ context.Context, _ *ccprovider.CCContext, _ *pb.ChaincodeDeploymentSpec) error {
 		return errors.New("Bad lunch; upset stomach")
@@ -1073,7 +1073,7 @@ func TestLaunchAndWaitLaunchError(t *testing.T) {
 	cccid := ccprovider.NewCCContext("testchannel", "testcc", "0", "landwtimertest_txid", false, nil, nil)
 
 	//actual test - container launch gives error
-	err := launcher.launchAndWaitForReady(context.Background(), cccid, cds)
+	err := launcher.startAndWaitForReady(context.Background(), cccid, cds)
 	if err == nil {
 		t.Fatalf("expected error but succeeded")
 	}
@@ -1324,7 +1324,7 @@ func TestCCFramework(t *testing.T) {
 	getHistory(t, chainID, ccname, ccSide, chaincodeSupport)
 
 	//just use the previous certGenerator for generating TLS key/pair
-	cr := chaincodeSupport.ContainerRuntime.(*ContainerRuntime)
+	cr := chaincodeSupport.Runtime.(*ContainerRuntime)
 	getLaunchConfigs(t, cr)
 
 	ccSide.Quit()

core/chaincode/config.go

@@ -56,7 +56,7 @@ func (c *Config) load() {
 	}
 	c.StartupTimeout = viper.GetDuration("chaincode.startuptimeout")
 	if c.StartupTimeout < minimumStartupTimeout {
-		c.StartupTimeout = 5 * time.Second
+		c.StartupTimeout = minimumStartupTimeout
 	}
 
 	c.LogFormat = viper.GetString("chaincode.logging.format")

core/chaincode/container_runtime.go

@@ -36,6 +36,13 @@ func (v ProcessFunc) Process(ctxt context.Context, vmtype string, req container.
 	return v(ctxt, vmtype, req)
 }
 
+// CertGenerator generates client certificates for chaincode.
+type CertGenerator interface {
+	// Generate returns a certificate and private key and associates
+	// the hash of the certificates with the given chaincode name
+	Generate(ccName string) (*accesscontrol.CertAndPrivKeyPair, error)
+}
+
 // ContainerRuntime is responsible for managing containerized chaincode.
 type ContainerRuntime struct {
 	CertGenerator CertGenerator
@@ -47,7 +54,7 @@ type ContainerRuntime struct {
 	PeerNetworkID string
 }
 
-// Start launches chaincode in a container runtime environment.
+// Start launches chaincode in a runtime environment.
 func (c *ContainerRuntime) Start(ctxt context.Context, cccid *ccprovider.CCContext, cds *pb.ChaincodeDeploymentSpec) error {
 	cname := cccid.GetCanonicalName()
 
@@ -60,7 +67,6 @@ func (c *ContainerRuntime) Start(ctxt context.Context, cccid *ccprovider.CCConte
 	chaincodeLogger.Debugf("start container with args: %s", strings.Join(lc.Args, " "))
 	chaincodeLogger.Debugf("start container with env:\n\t%s", strings.Join(lc.Envs, "\n\t"))
 
-	// ipcCtxt := context.WithValue(ctxt, ccintf.GetCCHandlerKey(), ccl.support)
 	builder := func() (io.Reader, error) { return platforms.GenerateDockerBuild(cds) }
 	scr := container.StartContainerReq{
 		Builder:       builder,

core/chaincode/exectransaction_test.go

@@ -554,7 +554,15 @@ func invokeExample02Transaction(ctxt context.Context, cccid *ccprovider.CCContex
 
 	if destroyImage {
 		chaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec})
-		dir := container.DestroyImageReq{CCID: ccintf.CCID{ChaincodeSpec: spec, NetworkID: chaincodeSupport.peerNetworkID, PeerID: chaincodeSupport.peerID}, Force: true, NoPrune: true}
+		dir := container.DestroyImageReq{
+			CCID: ccintf.CCID{
+				ChaincodeSpec: spec,
+				// NetworkID:     chaincodeSupport.peerNetworkID,
+				// PeerID:        chaincodeSupport.peerID,
+			},
+			Force:   true,
+			NoPrune: true,
+		}
 
 		_, err = container.VMCProcess(ctxt, container.DOCKER, dir)
 		if err != nil {
@@ -1106,8 +1114,8 @@ func TestQueries(t *testing.T) {
 	//the peer should handle this gracefully and not die
 
 	//save the original timeout and set a new timeout of 1 sec
-	origTimeout := chaincodeSupport.executetimeout
-	chaincodeSupport.executetimeout = time.Duration(1) * time.Second
+	origTimeout := chaincodeSupport.ExecuteTimeout
+	chaincodeSupport.ExecuteTimeout = time.Duration(1) * time.Second
 
 	//chaincode to sleep for 2 secs with timeout 1
 	args = util.ToChaincodeArgs(f, "marble001", "marble002", "2000")
@@ -1122,7 +1130,7 @@ func TestQueries(t *testing.T) {
 	}
 
 	//restore timeout
-	chaincodeSupport.executetimeout = origTimeout
+	chaincodeSupport.ExecuteTimeout = origTimeout
 
 	// querying for all marbles will return 101 marbles
 	// this query should return exactly 101 results (one call to Next())

core/chaincode/executetransaction_pvtdata_test.go

@@ -276,8 +276,8 @@ func TestQueriesPrivateData(t *testing.T) {
 	//the peer should handle this gracefully and not die
 
 	//save the original timeout and set a new timeout of 1 sec
-	origTimeout := chaincodeSupport.executetimeout
-	chaincodeSupport.executetimeout = time.Duration(1) * time.Second
+	origTimeout := chaincodeSupport.ExecuteTimeout
+	chaincodeSupport.ExecuteTimeout = time.Duration(1) * time.Second
 
 	//chaincode to sleep for 2 secs with timeout 1
 	args = util.ToChaincodeArgs(f, "marble001", "marble002", "2000")
@@ -292,7 +292,7 @@ func TestQueriesPrivateData(t *testing.T) {
 	}
 
 	//restore timeout
-	chaincodeSupport.executetimeout = origTimeout
+	chaincodeSupport.ExecuteTimeout = origTimeout
 
 	// querying for all marbles will return 101 marbles
 	// this query should return exactly 101 results (one call to Next())