FAB-11954 Pass peer addr and TLS together

Presently, the docker controller is configured with the peer address of
the chaincode server that chaincodes should connect back to.  This is a
bit awkward, because the other connection into, the TLS parameters, come
across at start time.  Passing these two together simplifies the concept
and prepares us to pass the two together to 'launch' in the external
builder.

Change-Id: Ia550cfe493d57e79ee61a5ce0230deede252c0f6
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

Author: Jason Yellick

core/chaincode/container_runtime.go

@@ -26,6 +26,7 @@ type ContainerRuntime struct {
 	CertGenerator   CertGenerator
 	ContainerRouter *container.Router
 	CACert          []byte
+	PeerAddress     string
 }
 
 // Start launches chaincode in a runtime environment.
@@ -55,7 +56,10 @@ func (c *ContainerRuntime) Start(ccci *ccprovider.ChaincodeContainerInfo, codePa
 	if err := c.ContainerRouter.Start(
 		ccintf.New(ccci.PackageID),
 		ccci.Type,
-		tlsConfig,
+		&ccintf.PeerConnection{
+			Address:   c.PeerAddress,
+			TLSConfig: tlsConfig,
+		},
 	); err != nil {
 		return errors.WithMessage(err, "error starting container")
 	}

core/chaincode/container_runtime_test.go

@@ -27,6 +27,7 @@ func TestContainerRuntimeStart(t *testing.T) {
 		ContainerRouter: &container.Router{
 			DockerVM: fakeVM,
 		},
+		PeerAddress: "peer-address",
 	}
 
 	ccci := &ccprovider.ChaincodeContainerInfo{
@@ -52,10 +53,11 @@ func TestContainerRuntimeStart(t *testing.T) {
 	assert.Equal(t, []byte("code-package"), codePackage)
 
 	assert.Equal(t, 1, fakeVM.StartCallCount())
-	ccid, ccType, tlsConfig := fakeVM.StartArgsForCall(0)
+	ccid, ccType, peerConnection := fakeVM.StartArgsForCall(0)
 	assert.Equal(t, ccintf.CCID("chaincode-name:chaincode-version"), ccid)
 	assert.Equal(t, "GOLANG", ccType)
-	assert.Nil(t, tlsConfig)
+	assert.Equal(t, "peer-address", peerConnection.Address)
+	assert.Nil(t, peerConnection.TLSConfig)
 }
 
 func TestContainerRuntimeStartErrors(t *testing.T) {

core/chaincode/exectransaction_test.go

@@ -152,9 +152,9 @@ func initPeer(chainIDs ...string) (*cm.Lifecycle, net.Listener, *ChaincodeSuppor
 					Registry: pr,
 					Client:   client,
 				},
-				PeerAddress: peerAddress,
 			},
 		},
+		PeerAddress: peerAddress,
 	}
 	userRunsCC := false
 	metricsProviders := &disabled.Provider{}

core/chaincode/mock/container_vm.go

@@ -34,6 +34,12 @@ func New(packageID persistence.PackageID) CCID {
 	return CCID(packageID.String())
 }
 
+// PeerConnection instructs the chaincode how to connect back to the peer
+type PeerConnection struct {
+	Address   string
+	TLSConfig *TLSConfig
+}
+
 // TLSConfig is used to pass the TLS context into the chaincode launch
 type TLSConfig struct {
 	ClientCert []byte

core/container/ccintf/ccintf.go

@@ -19,7 +19,7 @@ var vmLogger = flogging.MustGetLogger("container")
 //VM is an abstract virtual image for supporting arbitrary virual machines
 type VM interface {
 	Build(ccci *ccprovider.ChaincodeContainerInfo, codePackage []byte) error
-	Start(ccid ccintf.CCID, ccType string, tlsConfig *ccintf.TLSConfig) error
+	Start(ccid ccintf.CCID, ccType string, peerConnection *ccintf.PeerConnection) error
 	Stop(ccid ccintf.CCID) error
 	Wait(ccid ccintf.CCID) (int, error)
 }
@@ -55,8 +55,8 @@ func (r *Router) Build(ccci *ccprovider.ChaincodeContainerInfo, codePackage []by
 	return r.getVM(ccintf.New(ccci.PackageID)).Build(ccci, codePackage)
 }
 
-func (r *Router) Start(ccid ccintf.CCID, ccType string, tlsConfig *ccintf.TLSConfig) error {
-	return r.getVM(ccid).Start(ccid, ccType, tlsConfig)
+func (r *Router) Start(ccid ccintf.CCID, ccType string, peerConnection *ccintf.PeerConnection) error {
+	return r.getVM(ccid).Start(ccid, ccType, peerConnection)
 }
 
 func (r *Router) Stop(ccid ccintf.CCID) error {

core/container/container.go

@@ -40,22 +40,28 @@ var _ = Describe("Container", func() {
 				err := router.Start(
 					ccintf.CCID("start:name"),
 					"fake-ccType",
-					&ccintf.TLSConfig{
-						ClientKey:  []byte("key"),
-						ClientCert: []byte("cert"),
-						RootCert:   []byte("root"),
+					&ccintf.PeerConnection{
+						Address: "peer-address",
+						TLSConfig: &ccintf.TLSConfig{
+							ClientKey:  []byte("key"),
+							ClientCert: []byte("cert"),
+							RootCert:   []byte("root"),
+						},
 					},
 				)
 
 				Expect(err).To(MatchError("fake-start-error"))
 				Expect(fakeVM.StartCallCount()).To(Equal(1))
-				ccid, args, tlsConfig := fakeVM.StartArgsForCall(0)
+				ccid, args, peerConnection := fakeVM.StartArgsForCall(0)
 				Expect(ccid).To(Equal(ccintf.CCID("start:name")))
 				Expect(args).To(Equal("fake-ccType"))
-				Expect(tlsConfig).To(Equal(&ccintf.TLSConfig{
-					ClientKey:  []byte("key"),
-					ClientCert: []byte("cert"),
-					RootCert:   []byte("root"),
+				Expect(peerConnection).To(Equal(&ccintf.PeerConnection{
+					Address: "peer-address",
+					TLSConfig: &ccintf.TLSConfig{
+						ClientKey:  []byte("key"),
+						ClientCert: []byte("cert"),
+						RootCert:   []byte("root"),
+					},
 				}))
 			})
 		})

core/container/container_test.go

@@ -86,7 +86,6 @@ type DockerVM struct {
 	ChaincodePull   bool
 	NetworkMode     string
 	PlatformBuilder PlatformBuilder
-	PeerAddress     string
 }
 
 // HealthCheck checks if the DockerVM is able to communicate with the Docker
@@ -177,16 +176,16 @@ func (vm *DockerVM) Build(ccci *ccprovider.ChaincodeContainerInfo, codePackage [
 	return nil
 }
 
-func (vm *DockerVM) GetArgs(ccType string) ([]string, error) {
+func (vm *DockerVM) GetArgs(ccType string, peerAddress string) ([]string, error) {
 	// language specific arguments, possibly should be pushed back into platforms, but were simply
 	// ported from the container_runtime chaincode component
 	switch ccType {
 	case pb.ChaincodeSpec_GOLANG.String(), pb.ChaincodeSpec_CAR.String():
-		return []string{"chaincode", fmt.Sprintf("-peer.address=%s", vm.PeerAddress)}, nil
+		return []string{"chaincode", fmt.Sprintf("-peer.address=%s", peerAddress)}, nil
 	case pb.ChaincodeSpec_JAVA.String():
-		return []string{"/root/chaincode-java/start", "--peerAddress", vm.PeerAddress}, nil
+		return []string{"/root/chaincode-java/start", "--peerAddress", peerAddress}, nil
 	case pb.ChaincodeSpec_NODE.String():
-		return []string{"/bin/sh", "-c", fmt.Sprintf("cd /usr/local/src; npm start -- --peer.address %s", vm.PeerAddress)}, nil
+		return []string{"/bin/sh", "-c", fmt.Sprintf("cd /usr/local/src; npm start -- --peer.address %s", peerAddress)}, nil
 	default:
 		return nil, errors.Errorf("unknown chaincodeType: %s", ccType)
 	}
@@ -223,7 +222,7 @@ func GetEnv(ccid ccintf.CCID, tlsConfig *ccintf.TLSConfig) []string {
 }
 
 // Start starts a container using a previously created docker image
-func (vm *DockerVM) Start(ccid ccintf.CCID, ccType string, tlsConfig *ccintf.TLSConfig) error {
+func (vm *DockerVM) Start(ccid ccintf.CCID, ccType string, peerConnection *ccintf.PeerConnection) error {
 	imageName, err := vm.GetVMNameForDocker(ccid)
 	if err != nil {
 		return err
@@ -234,13 +233,13 @@ func (vm *DockerVM) Start(ccid ccintf.CCID, ccType string, tlsConfig *ccintf.TLS
 
 	vm.stopInternal(containerName)
 
-	args, err := vm.GetArgs(ccType)
+	args, err := vm.GetArgs(ccType, peerConnection.Address)
 	if err != nil {
 		return errors.WithMessage(err, "could not get args")
 	}
 	dockerLogger.Debugf("start container with args: %s", strings.Join(args, " "))
 
-	env := GetEnv(ccid, tlsConfig)
+	env := GetEnv(ccid, peerConnection.TLSConfig)
 	dockerLogger.Debugf("start container with env:\n\t%s", strings.Join(env, "\n\t"))
 
 	err = vm.createContainer(imageName, containerName, args, env)
@@ -256,16 +255,16 @@ func (vm *DockerVM) Start(ccid ccintf.CCID, ccType string, tlsConfig *ccintf.TLS
 	}
 
 	// upload TLS files to the container before starting it if needed
-	if tlsConfig != nil {
+	if peerConnection.TLSConfig != nil {
 		// the docker upload API takes a tar file, so we need to first
 		// consolidate the file entries to a tar
 		payload := bytes.NewBuffer(nil)
 		gw := gzip.NewWriter(payload)
 		tw := tar.NewWriter(gw)
 
-		cutil.WriteBytesToPackage(TLSClientKeyPath, tlsConfig.ClientKey, tw)
-		cutil.WriteBytesToPackage(TLSClientCertPath, tlsConfig.ClientCert, tw)
-		cutil.WriteBytesToPackage(TLSClientRootCertPath, tlsConfig.RootCert, tw)
+		cutil.WriteBytesToPackage(TLSClientKeyPath, peerConnection.TLSConfig.ClientKey, tw)
+		cutil.WriteBytesToPackage(TLSClientCertPath, peerConnection.TLSConfig.ClientCert, tw)
+		cutil.WriteBytesToPackage(TLSClientRootCertPath, peerConnection.TLSConfig.RootCert, tw)
 
 		// Write the tar file out
 		if err := tw.Close(); err != nil {

core/container/dockercontroller/dockercontroller.go

@@ -59,7 +59,9 @@ func TestIntegrationPath(t *testing.T) {
 	}, []byte("code-package"))
 	require.NoError(t, err)
 
-	err = dc.Start(ccid, "NODE", nil)
+	err = dc.Start(ccid, "NODE", &ccintf.PeerConnection{
+		Address: "peer-address",
+	})
 	require.NoError(t, err)
 
 	err = dc.Stop(ccid)
@@ -79,11 +81,9 @@ func TestGetArgs(t *testing.T) {
 		{"unknown-chaincode", pb.ChaincodeSpec_Type(999), []string{}, "unknown chaincodeType: 999"},
 	}
 	for _, tc := range tests {
-		vm := &DockerVM{
-			PeerAddress: "peer-address",
-		}
+		vm := &DockerVM{}
 
-		args, err := vm.GetArgs(tc.ccType.String())
+		args, err := vm.GetArgs(tc.ccType.String(), "peer-address")
 		if tc.expectedErr != "" {
 			assert.EqualError(t, err, tc.expectedErr)
 			continue
@@ -124,23 +124,26 @@ func Test_Start(t *testing.T) {
 	}
 
 	ccid := ccintf.CCID("simple:1.0")
-	tlsConfig := &ccintf.TLSConfig{
-		ClientKey:  []byte("key"),
-		ClientCert: []byte("cert"),
-		RootCert:   []byte("root"),
+	peerConnection := &ccintf.PeerConnection{
+		Address: "peer-address",
+		TLSConfig: &ccintf.TLSConfig{
+			ClientKey:  []byte("key"),
+			ClientCert: []byte("cert"),
+			RootCert:   []byte("root"),
+		},
 	}
 
 	// case 1: dockerClient.CreateContainer returns error
 	testError1 := errors.New("junk1")
 	dockerClient.CreateContainerReturns(nil, testError1)
-	err := dvm.Start(ccid, "GOLANG", tlsConfig)
+	err := dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).To(MatchError(testError1))
 	dockerClient.CreateContainerReturns(&docker.Container{}, nil)
 
 	// case 2: dockerClient.UploadToContainer returns error
 	testError2 := errors.New("junk2")
 	dockerClient.UploadToContainerReturns(testError2)
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err.Error()).To(ContainSubstring("junk2"))
 	dockerClient.UploadToContainerReturns(nil)
 
@@ -149,31 +152,31 @@ func Test_Start(t *testing.T) {
 	testError3 := errors.New("junk3")
 	dvm.AttachStdOut = true
 	dockerClient.CreateContainerReturns(nil, testError3)
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).To(MatchError(testError3))
 	dockerClient.CreateContainerReturns(&docker.Container{}, nil)
 
 	// case 4: GetArgs returns error
-	err = dvm.Start(ccid, "FAKE_TYPE", tlsConfig)
+	err = dvm.Start(ccid, "FAKE_TYPE", peerConnection)
 	gt.Expect(err).To(MatchError("could not get args: unknown chaincodeType: FAKE_TYPE"))
 
 	// Success cases
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).NotTo(HaveOccurred())
 
 	// dockerClient.StopContainer returns error
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).NotTo(HaveOccurred())
 
 	// dockerClient.KillContainer returns error
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).NotTo(HaveOccurred())
 
 	// dockerClient.RemoveContainer returns error
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).NotTo(HaveOccurred())
 
-	err = dvm.Start(ccid, "GOLANG", tlsConfig)
+	err = dvm.Start(ccid, "GOLANG", peerConnection)
 	gt.Expect(err).NotTo(HaveOccurred())
 }