Merge branch 'main' into dx-954-wait-longer-for-cl-node

Author: Tofel

.github/workflows/framework-golden-tests.yml

@@ -63,6 +63,10 @@ jobs:
             config: scalability.toml
             count: 1
             timeout: 10m
+          - name: TestLocalS3
+            config: local_s3.toml
+            count: 1
+            timeout: 10m
     name: ${{ matrix.test.name }}
     steps:
       - name: Checkout repo

book/src/SUMMARY.md

@@ -52,6 +52,8 @@
     - [Chainlink](framework/components/chainlink.md)
       - [Node](framework/components/chainlink/node.md)
       - [NodeSet](framework/components/chainlink/nodeset.md)
+    - [Storage](framework/components/storage.md)
+      - [S3](framework/components/storage/s3.md)
   - [Clients]()
     - [Chainlink]()
     - [RPC]()

book/src/framework/components/storage.md

@@ -0,0 +1,3 @@
+# Storage
+
+Here we store `Storage` components: S3.

book/src/framework/components/storage/s3.md

@@ -0,0 +1,63 @@
+# S3
+
+The framework contains local S3 provider.
+Currently, we support [MinIO](github.com/minio/minio).
+
+## Configuration
+```toml
+[local_s3]
+host = "minio"
+port = 9000
+console_port = 9001
+access_key = "(default:random)"
+secret_key = "(default:random)"
+bucket = "test-bucket"
+region = "us-east-1"
+```
+
+Example values are defaults.
+
+## Usage
+
+```golang
+package my_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/s3provider"
+	"github.com/smartcontractkit/chainlink-testing-framework/framework"
+	"github.com/stretchr/testify/require"
+)
+
+type Config struct {
+	S3Config *s3provider.Input `toml:"local_s3" validate:"required"`
+}
+
+func TestLocalS3(t *testing.T) {
+	in, err := framework.Load[Config](t)
+	require.NoError(t, err)
+
+	output, err := NewMinioFactory().NewFrom(in)
+	require.NoError(t, err)
+
+	t.log(fmt.Printf("%#v", output))
+}
+```
+
+Alternatively, the component supports Options pattern and can be created from code:
+```golang
+    // ...
+    s3provider, err := NewMinioFactory().New(
+        WithPort(port),
+        WithConsolePort(consolePort),
+        WithAccessKey(accessKey),
+        WithSecretKey(secretKey),
+    )
+    require.NoError(t, err)
+
+    output := s3provider.Output()
+	// ...
+```

framework/.changeset/v0.8.6.md

@@ -0,0 +1 @@
+- Aptos support for arm64

framework/.changeset/v0.8.7.md

@@ -0,0 +1 @@
+- Allow host network option for GAP integration

framework/.changeset/v0.8.8.md

@@ -0,0 +1 @@
+- Local S3 provider

framework/components/blockchain/aptos.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/docker/docker/api/types/container"
@@ -14,8 +15,10 @@ import (
 )
 
 const (
-	DefaultAptosAPIPort    = "8080"
-	DefaultAptosFaucetPort = "8081"
+	DefaultAptosAPIPort     = "8080"
+	DefaultAptosFaucetPort  = "8081"
+	DefaultAptosArm64Image  = "ghcr.io/friedemannf/aptos-tools:aptos-node-v1.30.2-rc"
+	DefaultAptosX86_64Image = "aptoslabs/tools:aptos-node-v1.27.2"
 )
 
 var (
@@ -25,7 +28,16 @@ var (
 
 func defaultAptos(in *Input) {
 	if in.Image == "" {
-		in.Image = "aptoslabs/tools:aptos-node-v1.27.2"
+		// Aptos doesn't support an official arm64 image yet, so we use a custom image for now
+		// CI Runners use x86_64 images, so CI checks will use the official image
+		if runtime.GOARCH == "arm64" {
+			// Uses an unofficial image built for arm64
+			framework.L.Warn().Msgf("Using unofficial Aptos image for arm64 %s", DefaultAptosArm64Image)
+			in.Image = DefaultAptosArm64Image
+		} else {
+			// Official Aptos image
+			in.Image = DefaultAptosX86_64Image
+		}
 	}
 	framework.L.Warn().Msgf("Aptos node API can only be exposed on port %s!", DefaultAptosAPIPort)
 	if in.Port == "" {
@@ -68,6 +80,14 @@ func newAptos(in *Input) (*Output, error) {
 		cmd = append(cmd, in.DockerCmdParamsOverrides...)
 	}
 
+	// Set image platform based on architecture
+	var imagePlatform string
+	if runtime.GOARCH == "arm64" {
+		imagePlatform = "linux/arm64"
+	} else {
+		imagePlatform = "linux/amd64"
+	}
+
 	req := testcontainers.ContainerRequest{
 		Image:        in.Image,
 		ExposedPorts: exposedPorts,
@@ -82,7 +102,7 @@ func newAptos(in *Input) (*Output, error) {
 			h.PortBindings = bindings
 			framework.ResourceLimitsFunc(h, in.ContainerResources)
 		},
-		ImagePlatform: "linux/amd64",
+		ImagePlatform: imagePlatform,
 		Cmd:           cmd,
 		Files: []testcontainers.ContainerFile{
 			{

framework/components/blockchain/blockchain.go

@@ -54,6 +54,10 @@ type Input struct {
 	SolanaPrograms     map[string]string             `toml:"solana_programs"`
 	ContainerResources *framework.ContainerResources `toml:"resources"`
 	CustomPorts        []string                      `toml:"custom_ports"`
+
+	// GAPv2 specific params
+	HostNetworkMode  bool   `toml:"host_network_mode"`
+	CertificatesPath string `toml:"certificates_path"`
 }
 
 // Output is a blockchain network output, ChainID and one or more nodes that forms the network

framework/components/blockchain/containers.go

@@ -13,6 +13,8 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/framework"
 )
 
+const DefaultUbuntuCACertificatePath = "/etc/ssl/certs/ca-certificates.crt"
+
 type ExposeWs = bool
 
 const (
@@ -28,20 +30,36 @@ func baseRequest(in *Input, useWS ExposeWs) testcontainers.ContainerRequest {
 		exposedPorts = append(exposedPorts, fmt.Sprintf("%s/tcp", in.WSPort))
 	}
 
-	return testcontainers.ContainerRequest{
-		Name:     containerName,
-		Labels:   framework.DefaultTCLabels(),
-		Networks: []string{framework.DefaultNetworkName},
-		NetworkAliases: map[string][]string{
-			framework.DefaultNetworkName: {containerName},
-		},
-		ExposedPorts: exposedPorts,
+	req := testcontainers.ContainerRequest{
+		Name:   containerName,
+		Labels: framework.DefaultTCLabels(),
 		HostConfigModifier: func(h *container.HostConfig) {
-			h.PortBindings = framework.MapTheSamePort(exposedPorts...)
 			framework.ResourceLimitsFunc(h, in.ContainerResources)
+			if in.HostNetworkMode {
+				h.NetworkMode = "host"
+			} else {
+				h.PortBindings = framework.MapTheSamePort(exposedPorts...)
+			}
 		},
 		WaitingFor: wait.ForListeningPort(nat.Port(in.Port)).WithStartupTimeout(1 * time.Minute).WithPollInterval(200 * time.Millisecond),
 	}
+	if !in.HostNetworkMode {
+		req.ExposedPorts = exposedPorts
+		req.Networks = []string{framework.DefaultNetworkName}
+		req.NetworkAliases = map[string][]string{
+			framework.DefaultNetworkName: {containerName},
+		}
+	}
+	if in.CertificatesPath != "" {
+		req.Files = []testcontainers.ContainerFile{
+			{
+				HostFilePath:      in.CertificatesPath,
+				ContainerFilePath: DefaultUbuntuCACertificatePath,
+				FileMode:          0644,
+			},
+		}
+	}
+	return req
 }
 
 func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest, useWS bool) (*Output, error) {
@@ -59,10 +77,18 @@ func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest, u
 		return nil, err
 	}
 
-	bindPort := req.ExposedPorts[0]
-	mp, err := c.MappedPort(ctx, nat.Port(bindPort))
-	if err != nil {
-		return nil, err
+	// specific case to bridge with GAPv2 in CI
+	// we run blockchains on "host" network for connectivity
+	var exposedPort string
+	if in.HostNetworkMode {
+		exposedPort = in.Port
+	} else {
+		bindPort := req.ExposedPorts[0]
+		ep, err := c.MappedPort(ctx, nat.Port(bindPort))
+		if err != nil {
+			return nil, err
+		}
+		exposedPort = ep.Port()
 	}
 
 	containerName := req.Name
@@ -76,8 +102,8 @@ func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest, u
 		Container:     c,
 		Nodes: []*Node{
 			{
-				ExternalWSUrl:   fmt.Sprintf("ws://%s:%s", host, mp.Port()),
-				ExternalHTTPUrl: fmt.Sprintf("http://%s:%s", host, mp.Port()),
+				ExternalWSUrl:   fmt.Sprintf("ws://%s:%s", host, exposedPort),
+				ExternalHTTPUrl: fmt.Sprintf("http://%s:%s", host, exposedPort),
 				InternalWSUrl:   fmt.Sprintf("ws://%s:%s", containerName, in.Port),
 				InternalHTTPUrl: fmt.Sprintf("http://%s:%s", containerName, in.Port),
 			},