chip ingress support + proto import

Author: Tofel

framework/components/chip_ingress/chip_ingress.go

@@ -0,0 +1,197 @@
+package chipingressset
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	networkTypes "github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
+	"github.com/pkg/errors"
+	"github.com/smartcontractkit/chainlink-testing-framework/framework"
+	"github.com/testcontainers/testcontainers-go/modules/compose"
+	"github.com/testcontainers/testcontainers-go/wait"
+)
+
+type Output struct {
+	ChipIngress *ChipIngressOutput
+	RedPanda    *RedPandaOutput
+}
+
+type ChipIngressOutput struct {
+	GRPCInternalURL string
+	GRPCExternalURL string
+}
+
+type RedPandaOutput struct {
+	SchemaRegistryInternalURL string
+	SchemaRegistryExternalURL string
+	KafkaInternalURL          string
+	KafkaExternalURL          string
+}
+
+type Input struct {
+	ComposeFile string   `toml:"compose_file"`
+	Topics      []string `toml:"topics"`
+	Output      *Output  `toml:"output"`
+	UseCache    bool     `toml:"use_cache"`
+}
+
+func defaultChipIngress(in *Input) *Input {
+	if in.ComposeFile == "" {
+		in.ComposeFile = "./docker-compose.yml"
+	}
+	return in
+}
+
+const (
+	DEFAULT_CHIP_INGRESS_GRPC_PORT    = "50051"
+	DEFAULT_CHIP_INGRESS_SERVICE_NAME = "chip-ingress"
+
+	DEFAULT_RED_PANDA_SCHEMA_REGISTRY_PORT = "18081"
+	DEFAULT_RED_PANDA_KAFKA_PORT           = "19092"
+	DEFAULT_RED_PANDA_SERVICE_NAME         = "redpanda-0"
+)
+
+func New(in *Input) (*Output, error) {
+	if in == nil {
+		return nil, errors.New("input is nil")
+	}
+
+	if in.UseCache {
+		if in.Output != nil {
+			return in.Output, nil
+		}
+	}
+
+	in = defaultChipIngress(in)
+	identifier := framework.DefaultTCName(DEFAULT_CHIP_INGRESS_SERVICE_NAME)
+
+	stack, stackErr := compose.NewDockerComposeWith(
+		compose.WithStackFiles(in.ComposeFile),
+		compose.StackIdentifier(identifier),
+	)
+	if stackErr != nil {
+		return nil, errors.Wrap(stackErr, "failed to create compose stack for Chip Ingress")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+
+	upErr := stack.
+		WithEnv(map[string]string{
+			"BASIC_AUTH_ENABLED": "false",
+			"BASIC_AUTH_PREFIX":  "",
+		}).
+		Up(ctx)
+
+	if upErr != nil {
+		return nil, errors.Wrap(upErr, "failed to start stack for Chip Ingress")
+	}
+
+	stack.WaitForService(DEFAULT_CHIP_INGRESS_SERVICE_NAME,
+		wait.ForLog("GRPC server is live").WithPollInterval(200*time.Millisecond).WithStartupTimeout(1*time.Minute),
+	)
+
+	chipIngressContainer, ingressErr := stack.ServiceContainer(ctx, DEFAULT_CHIP_INGRESS_SERVICE_NAME)
+	if ingressErr != nil {
+		return nil, errors.Wrap(ingressErr, "failed to get chip-ingress container")
+	}
+
+	cli, cliErr := client.NewClientWithOpts(
+		client.FromEnv,
+		client.WithAPIVersionNegotiation(),
+	)
+	if cliErr != nil {
+		return nil, errors.Wrap(cliErr, "failed to create docker client")
+	}
+	defer cli.Close()
+
+	timeout := time.After(1 * time.Minute)
+	tick := time.Tick(500 * time.Millisecond)
+
+	// so let's try to connect to the default network a couple of times, there must be a race condition in Docker
+	// and even when network sandbox has been created and container is running, this call can still fail
+	// retrying is simpler than trying to figure out how to correctly wait for the network sandbox to be ready
+	var connectDefaultNetwork = func() error {
+		for {
+			select {
+			case <-timeout:
+				return fmt.Errorf("timeout while trying to connect chip-ingress to default network")
+			case <-tick:
+				if networkErr := cli.NetworkConnect(
+					ctx,
+					framework.DefaultNetworkName,
+					chipIngressContainer.ID,
+					&networkTypes.EndpointSettings{
+						Aliases: []string{identifier},
+					},
+				); networkErr != nil && !strings.Contains(networkErr.Error(), "already exists in network") {
+					fmt.Println("failed to connect to default network", networkErr)
+					continue
+				}
+				fmt.Println("connected to default network")
+				return nil
+			}
+		}
+	}
+
+	if connectErr := connectDefaultNetwork(); connectErr != nil {
+		return nil, errors.Wrap(connectErr, "failed to connect chip-ingress to default network")
+	}
+
+	// verify that the container is connected to framework's network
+	inspected, inspectErr := cli.ContainerInspect(ctx, chipIngressContainer.ID)
+	if inspectErr != nil {
+		return nil, errors.Wrapf(inspectErr, "failed to inspect container %s", chipIngressContainer.ID)
+	}
+
+	_, ok := inspected.NetworkSettings.Networks[framework.DefaultNetworkName]
+	if !ok {
+		return nil, fmt.Errorf("container %s is NOT on network %s", chipIngressContainer.ID, framework.DefaultNetworkName)
+	}
+
+	// get hosts and ports for chip-ingress and redpanda
+	chipIngressExternalHost, chipIngressExternalHostErr := chipIngressContainer.Host(ctx)
+	if chipIngressExternalHostErr != nil {
+		return nil, errors.Wrap(chipIngressExternalHostErr, "failed to get host for Chip Ingress")
+	}
+	chipIngressExternalPort, chipIngressExternalPortErr := chipIngressContainer.MappedPort(ctx, DEFAULT_CHIP_INGRESS_GRPC_PORT)
+	if chipIngressExternalPortErr != nil {
+		return nil, errors.Wrap(chipIngressExternalPortErr, "failed to get mapped port for Chip Ingress")
+	}
+
+	redpandaContainer, redpandaErr := stack.ServiceContainer(ctx, DEFAULT_RED_PANDA_SERVICE_NAME)
+	if redpandaErr != nil {
+		return nil, errors.Wrap(redpandaErr, "failed to get redpanda container")
+	}
+
+	redpandaExternalHost, redpandaExternalHostErr := redpandaContainer.Host(ctx)
+	if redpandaExternalHostErr != nil {
+		return nil, errors.Wrap(redpandaExternalHostErr, "failed to get host for Red Panda")
+	}
+	redpandaExternalKafkaPort, redpandaExternalKafkaPortErr := redpandaContainer.MappedPort(ctx, DEFAULT_RED_PANDA_KAFKA_PORT)
+	if redpandaExternalKafkaPortErr != nil {
+		return nil, errors.Wrap(redpandaExternalKafkaPortErr, "failed to get mapped port for Red Panda")
+	}
+	redpandaExternalSchemaRegistryPort, redpandaExternalSchemaRegistryPortErr := redpandaContainer.MappedPort(ctx, DEFAULT_RED_PANDA_SCHEMA_REGISTRY_PORT)
+	if redpandaExternalSchemaRegistryPortErr != nil {
+		return nil, errors.Wrap(redpandaExternalSchemaRegistryPortErr, "failed to get mapped port for Red Panda")
+	}
+
+	output := &Output{
+		ChipIngress: &ChipIngressOutput{
+			GRPCInternalURL: fmt.Sprintf("http://%s:%s", DEFAULT_CHIP_INGRESS_SERVICE_NAME, DEFAULT_CHIP_INGRESS_GRPC_PORT),
+			GRPCExternalURL: fmt.Sprintf("http://%s:%s", chipIngressExternalHost, chipIngressExternalPort.Port()),
+		},
+		RedPanda: &RedPandaOutput{
+			SchemaRegistryInternalURL: fmt.Sprintf("http://%s:%s", DEFAULT_RED_PANDA_SERVICE_NAME, DEFAULT_RED_PANDA_SCHEMA_REGISTRY_PORT),
+			SchemaRegistryExternalURL: fmt.Sprintf("http://%s:%s", redpandaExternalHost, redpandaExternalSchemaRegistryPort.Port()),
+			KafkaInternalURL:          fmt.Sprintf("%s:%s", DEFAULT_RED_PANDA_SERVICE_NAME, DEFAULT_RED_PANDA_KAFKA_PORT),
+			KafkaExternalURL:          fmt.Sprintf("%s:%s", redpandaExternalHost, redpandaExternalKafkaPort.Port()),
+		},
+	}
+
+	return output, nil
+}

framework/components/chip_ingress_set/chip_ingress.go

@@ -6,7 +6,6 @@ services:
     depends_on:
       - redpanda-0
       - otel-lgtm
-
     restart: on-failure
     tty: true
     command: ["write-service"]
@@ -19,8 +18,9 @@ services:
       SERVER_METRICS_OTEL_EXPORTER_GRPC_ENDPOINT: ${SERVER_METRICS_OTEL_EXPORTER_GRPC_ENDPOINT:-otel-lgtm:4317}
       KAFKA_BROKERS: "redpanda-0:9092"
       SCHEMA_REGISTRY_URL: "http://redpanda-0:8081"
-      BASIC_AUTH_ENABLED: ${BASIC_AUTH_ENABLED:-true}
-      BASIC_AUTH_PREFIX: ${BASIC_AUTH_PREFIX:-CE_SA_}
+      # this has been modified and default values were removed, somehow we cannot override them in testcontainers-go
+      BASIC_AUTH_ENABLED: ${BASIC_AUTH_ENABLED:-}
+      BASIC_AUTH_PREFIX: ${BASIC_AUTH_PREFIX:-}
       CE_SA_BEHOLDER_DEMO_CLIENT: |
         {"username": "beholder-demo-client", "password": "password", "allowed_domains": ["*"]}
       CSA_AUTH_ENABLED: ${CSA_AUTH_ENABLED:-false}
@@ -33,8 +33,8 @@ services:
       - "9090:9090"
       - "9092:9091"
     healthcheck:
-      # test: [ "CMD", "grpc_health_probe", "-addr=localhost:50051" ]
-      test: [ "CMD-SHELL", "sleep 1"]
+      test: [ "CMD", "grpc_health_probe", "-addr=localhost:50051" ]
+      # test: [ "CMD-SHELL", "sleep 1"]
       interval: 200ms
       timeout: 10s
       retries: 10