Fix IRB container package

config.mk

@@ -39,7 +39,7 @@ DOCKER_CMD := docker
 # (Note: vars are exported as env variables as we also need them in various scripts)
 # alternatives for SGX_MODE: SIM or HW
 export SGX_MODE ?= SIM
-export SGX_BUILD ?= PRERELEASE
+export SGX_BUILD ?= DEBUG
 export SGX_SSL ?= /opt/intel/sgxssl
 export SGX_SDK ?= /opt/intel/sgxsdk
 export SGX_ARCH ?= x64

samples/demos/Makefile

@@ -8,6 +8,9 @@ include $(TOP)/build.mk
 
 DEMOS = irb
 
-build clean:
+test:
+	$(foreach DIR, $(DEMOS), $(MAKE) -C $(DIR) || exit;)
+
+clean:
 	$(foreach DIR, $(DEMOS), $(MAKE) -C $(DIR) $@ || exit;)
 

samples/demos/irb/.gitignore

@@ -1,3 +1,3 @@
-cmd/**
+cmd/
 users/**
 pkg/protos/**

samples/demos/irb/Makefile

@@ -7,8 +7,6 @@ include $(TOP)/build.mk
 
 COMPONENTS = protos chaincode experimenter
 
-all: pull-images ercc build test
-
 pull-images:
 	$(DOCKER) pull redis:latest
 	$(DOCKER) pull hyperledger/fabric-baseos:2.5
@@ -20,11 +18,11 @@ ercc:
 	make -C ${FPC_PATH}/ercc all docker
 	$(DOCKER) image tag fpc/ercc:$(FPC_VERSION) fpc/ercc:latest
 
-build: ercc
+build: pull-images ercc
 	$(foreach DIR, $(COMPONENTS), $(MAKE) -C $(DIR) $@ || exit;)
 
 test:
-	$(GO) test -v ./...
+	$(GO) test -v -failfast ./...
 
 run:
 	$(GO) test -v .

samples/demos/irb/experimenter/Makefile

@@ -17,4 +17,4 @@ run: build
 	$(MAKE) -C worker stop-docker run-docker
 
 test:
-	$(GO) test -v ./...
+	$(GO) test -v -failfast ./...

samples/demos/irb/experimenter/test/worker_test.go

@@ -8,24 +8,35 @@ package test
 
 import (
 	"bytes"
+	"cmp"
+	"context"
 	"fmt"
 	"io"
 	"net/http"
+	"os"
+	"strconv"
 	"testing"
-	"time"
 
-	"github.com/hyperledger/fabric-private-chaincode/samples/demos/irb/pkg/container"
+	"github.com/docker/go-connections/nat"
 	"github.com/hyperledger/fabric-private-chaincode/samples/demos/irb/pkg/crypto"
 	pb "github.com/hyperledger/fabric-private-chaincode/samples/demos/irb/pkg/protos"
 	"github.com/hyperledger/fabric-private-chaincode/samples/demos/irb/pkg/storage"
-	"github.com/hyperledger/fabric-private-chaincode/samples/demos/irb/pkg/utils"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/require"
+	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/network"
+	"github.com/testcontainers/testcontainers-go/wait"
 	"google.golang.org/protobuf/proto"
 )
 
-func requestAttestation() ([]byte, error) {
+func experimentEndpoint(ep string) string {
+	host := os.Getenv("EXPERIMENT_HOST")
+	port := os.Getenv("EXPERIMENT_PORT")
+	return fmt.Sprintf("http://%s:%s/%s", host, port, ep)
+}
 
-	resp, err := http.Get("http://localhost:5000/attestation")
+func requestAttestation() ([]byte, error) {
+	resp, err := http.Get(experimentEndpoint("attestation"))
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +68,6 @@ func requestAttestation() ([]byte, error) {
 }
 
 func submitEvaluationPack(pk []byte, req *pb.RegisterDataRequest) error {
-
 	epm := &pb.EvaluationPackMessage{}
 	epm.RegisteredData = []*pb.RegisterDataRequest{req}
 
@@ -92,7 +102,7 @@ func submitEvaluationPack(pk []byte, req *pb.RegisterDataRequest) error {
 		return err
 	}
 
-	resp, err := http.Post("http://localhost:5000/execute-evaluationpack", "", bytes.NewBuffer(evalPackBytes))
+	resp, err := http.Post(experimentEndpoint("execute-evaluationpack"), "", bytes.NewBuffer(evalPackBytes))
 	if err != nil {
 		return err
 	}
@@ -122,8 +132,15 @@ func upload() (*pb.RegisterDataRequest, error) {
 		return nil, errors.Wrap(err, "cannot encrypt message")
 	}
 
+	host := cmp.Or(os.Getenv("REDIS_HOST"), "localhost")
+	port, err := strconv.Atoi(cmp.Or(os.Getenv("REDIS_PORT"), strconv.Itoa(storage.DefaultRedisPort)))
+	if err != nil {
+		return nil, errors.Wrap(err, "invalid redis port")
+	}
+	password := cmp.Or(os.Getenv("REDIS_PASSWORD"))
+
 	// upload encrypted data
-	kvs := storage.NewClient()
+	kvs := storage.NewClient(storage.WithHost(host), storage.WithPort(port), storage.WithPassword(password))
 	handle, err := kvs.Upload(encryptedData)
 	if err != nil {
 		return nil, errors.Wrap(err, "cannot upload data to kvs")
@@ -134,7 +151,7 @@ func upload() (*pb.RegisterDataRequest, error) {
 		PublicKey: []byte("some verification key"),
 	}
 
-	//build request
+	// build request
 	registerDataRequest := &pb.RegisterDataRequest{
 		Participant:   &userIdentity,
 		DecryptionKey: sk,
@@ -148,70 +165,85 @@ func upload() (*pb.RegisterDataRequest, error) {
 const networkID = "mytestnetwork"
 
 func TestWorker(t *testing.T) {
-
-	network := &container.Network{Name: networkID}
-	err := network.Create()
-	defer network.Remove()
-	if err != nil {
-		panic(err)
-	}
-
-	// setup redis
-	redis := &container.Container{
-		Image:    "redis",
-		Name:     "redis-container",
-		HostIP:   "localhost",
-		HostPort: "6379",
-		Network:  networkID,
-	}
-	err = redis.Start()
-	defer redis.Stop()
-	if err != nil {
-		panic(err)
-	}
-
-	// setup experiment container
-	experiment := &container.Container{
-		Image:    "irb-experimenter-worker",
-		Name:     "experiment-container",
-		HostIP:   "localhost",
-		HostPort: "5000",
-		Env:      []string{"REDIS_HOST=redis-container"},
-		Network:  networkID,
-	}
-	err = experiment.Start()
-	defer experiment.Stop()
-	if err != nil {
-		panic(err)
-	}
-
-	// let's wait until experiment service is up an running
-	err = utils.Retry(func() bool {
-		resp, err := http.Get("http://localhost:5000/info")
-		if err != nil {
-			return false
-		}
-		return resp.StatusCode == 200
-	}, 5, 60*time.Second, 2*time.Second)
-	if err != nil {
-		panic(err)
-	}
+	ctx := context.Background()
+
+	// network
+	net, err := network.New(ctx)
+	require.NoError(t, err)
+	defer func() {
+		err := net.Remove(ctx)
+		require.NoError(t, err)
+	}()
+	networkName := net.Name
+
+	// redis
+	redisImageName := "redis"
+	redisExportedPort := fmt.Sprintf("%d/tcp", storage.DefaultRedisPort)
+	redis, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: testcontainers.ContainerRequest{
+			Image:        redisImageName,
+			ExposedPorts: []string{redisExportedPort},
+			Networks:     []string{networkName},
+			// WaitingFor:   wait.ForLog("* Ready to accept connections"),
+			WaitingFor: wait.ForExposedPort(),
+		},
+		Started: true,
+	})
+	require.NoError(t, err)
+	defer func() {
+		err := redis.Terminate(ctx)
+		require.NoError(t, err)
+	}()
+
+	redisHost, err := redis.Host(ctx)
+	require.NoError(t, err)
+	redisPort, err := redis.MappedPort(ctx, nat.Port(redisExportedPort))
+	require.NoError(t, err)
+	t.Logf("redisHost: %s:%s", redisHost, redisPort.Port())
+
+	os.Setenv("REDIS_HOST", redisHost)
+	os.Setenv("REDIS_PORT", redisPort.Port())
+
+	// experiment
+	experimentImageName := "irb-experimenter-worker"
+	experiment, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: testcontainers.ContainerRequest{
+			Image:        experimentImageName,
+			ExposedPorts: []string{"5000/tcp"},
+			Networks:     []string{networkName},
+			Env: map[string]string{
+				"REDIS_HOST": redisHost,
+				"REDIS_PORT": redisPort.Port(),
+			},
+			WaitingFor: wait.ForExposedPort(),
+		},
+		Started: true,
+	})
+	require.NoError(t, err)
+	defer func() {
+		err := experiment.Terminate(ctx)
+		require.NoError(t, err)
+	}()
+
+	experimentHost, err := experiment.Host(ctx)
+	require.NoError(t, err)
+	experimentPort, err := experiment.MappedPort(ctx, "5000/tcp")
+	require.NoError(t, err)
+	t.Logf("experimentHost: %s:%s", experimentHost, experimentPort.Port())
+
+	os.Setenv("EXPERIMENT_HOST", experimentHost)
+	os.Setenv("EXPERIMENT_PORT", experimentPort.Port())
 
 	req, err := upload()
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 
 	fmt.Println("Testing attestation...")
 	pk, err := requestAttestation()
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 
 	fmt.Println("Testing evaluation pack...")
-	if err := submitEvaluationPack(pk, req); err != nil {
-		panic(err)
-	}
+	err = submitEvaluationPack(pk, req)
+	require.NoError(t, err)
 
 	fmt.Println("Test done.")
 }