WIP: shared nodeset

Author: skudasov

framework/components/blockchain/anvil.go

@@ -17,7 +17,7 @@ const (
 // deployAnvil deploy foundry anvil node
 func deployAnvil(in *Input) (*Output, error) {
 	ctx := context.Background()
-	entryPoint := []string{"anvil", "--host", "0.0.0.0", "--port", in.Port, "--chain-id", in.ChainID}
+	entryPoint := []string{"anvil", "--host", "0.0.0.0", "--port", in.Port, "--chain-id", in.ChainID, "-b", "1"}
 	entryPoint = append(entryPoint, in.DockerCmdParamsOverrides...)
 	bindPort := fmt.Sprintf("%s/tcp", in.Port)
 	containerName := framework.DefaultTCName("anvil")

framework/components/clnode/clnode.go

@@ -53,9 +53,9 @@ type NodeOut struct {
 	DockerP2PUrl string `toml:"p2p_docker_internal_url"`
 }
 
-// NewNode create a new Chainlink node with some image:tag and one or several configs
+// NewNodeWithDB create a new Chainlink node with some image:tag and one or several configs
 // see config params: TestConfigOverrides, UserConfigOverrides, etc
-func NewNode(in *Input) (*Output, error) {
+func NewNodeWithDB(in *Input) (*Output, error) {
 	if in.Out != nil && in.Out.UseCache {
 		return in.Out, nil
 	}
@@ -76,6 +76,23 @@ func NewNode(in *Input) (*Output, error) {
 	return out, nil
 }
 
+func NewNode(in *Input, pgOut *postgres.Output) (*Output, error) {
+	if in.Out != nil && in.Out.UseCache {
+		return in.Out, nil
+	}
+	nodeOut, err := newNode(in, pgOut)
+	if err != nil {
+		return nil, err
+	}
+	out := &Output{
+		UseCache:   true,
+		Node:       nodeOut,
+		PostgreSQL: pgOut,
+	}
+	in.Out = out
+	return out, nil
+}
+
 func newNode(in *Input, pgOut *postgres.Output) (*NodeOut, error) {
 	ctx := context.Background()
 

framework/components/node_set_extended/node_set_extended.go

@@ -27,7 +27,7 @@ func NewExtendedNodeSet(in *Input, bcOut *blockchain.Output, fakeUrl string) (*O
 		}
 		n.Node.TestConfigOverrides = net
 		n.DataProviderURL = fakeUrl
-		o, err := clnode.NewNode(n)
+		o, err := clnode.NewNodeWithDB(n)
 		if err != nil {
 			return nil, err
 		}

framework/components/postgres/postgres.go

@@ -7,6 +7,8 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/framework"
 	"github.com/testcontainers/testcontainers-go"
 	tcwait "github.com/testcontainers/testcontainers-go/wait"
+	"os"
+	"strings"
 	"time"
 )
 
@@ -17,6 +19,7 @@ type Input struct {
 	User      string  `toml:"user" validate:"required" default:"chainlink"`
 	Password  string  `toml:"password" validate:"required" default:"thispasswordislongenough"`
 	Database  string  `toml:"database" validate:"required" default:"chainlink"`
+	Databases int     `toml:"databases" validate:"required" default:"20"`
 	Port      string  `toml:"port" validate:"required" default:"5432"`
 	Out       *Output `toml:"out"`
 }
@@ -33,6 +36,23 @@ func NewPostgreSQL(in *Input) (*Output, error) {
 
 	containerName := framework.DefaultTCName("postgresql")
 
+	var sqlCommands []string
+	for i := 0; i <= in.Databases; i++ {
+		sqlCommands = append(sqlCommands, fmt.Sprintf("CREATE DATABASE db_%d;", i))
+	}
+	sqlCommands = append(sqlCommands, "ALTER USER chainlink WITH SUPERUSER;")
+	initSQL := strings.Join(sqlCommands, "\n")
+	initFile, err := os.CreateTemp("", "init-*.sql")
+	if err != nil {
+		return nil, err
+	}
+	if _, err := initFile.WriteString(initSQL); err != nil {
+		return nil, err
+	}
+	if err := initFile.Close(); err != nil {
+		return nil, err
+	}
+
 	req := testcontainers.ContainerRequest{
 		AlwaysPullImage: in.PullImage,
 		Image:           fmt.Sprintf("%s:%s", in.Image, in.Tag),
@@ -51,9 +71,16 @@ func NewPostgreSQL(in *Input) (*Output, error) {
 		Cmd: []string{
 			"postgres", "-c", fmt.Sprintf("port=%s", in.Port),
 		},
+		Files: []testcontainers.ContainerFile{
+			{
+				HostFilePath:      initFile.Name(),
+				ContainerFilePath: "/docker-entrypoint-initdb.d/init.sql",
+				FileMode:          0644,
+			},
+		},
 		WaitingFor: tcwait.ForExec([]string{"psql", "-h", "127.0.0.1",
 			"-U", in.User, "-p", in.Port, "-c", "select", "1", "-d", in.Database}).
-			WithStartupTimeout(10 * time.Second),
+			WithStartupTimeout(20 * time.Second),
 	}
 	c, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
 		ContainerRequest: req,

framework/components/simple_node_set/node_set.go

@@ -1,8 +1,13 @@
 package simple_node_set
 
 import (
+	"fmt"
 	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
 	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/clnode"
+	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/postgres"
+	"golang.org/x/sync/errgroup"
+	"strings"
+	"sync"
 )
 
 type Input struct {
@@ -31,7 +36,7 @@ func NewNodeSet(in *Input, bcOut *blockchain.Output, fakeUrl string) (*Output, e
 		newIn.Node.TestConfigOverrides = net
 		newIn.DataProviderURL = fakeUrl
 		newIn.Out = nil
-		o, err := clnode.NewNode(newIn)
+		o, err := clnode.NewNodeWithDB(newIn)
 		if err != nil {
 			return nil, err
 		}
@@ -44,3 +49,49 @@ func NewNodeSet(in *Input, bcOut *blockchain.Output, fakeUrl string) (*Output, e
 	in.Out = out
 	return out, nil
 }
+
+func NewSharedDBNodeSet(in *Input, bcOut *blockchain.Output, fakeUrl string) (*Output, error) {
+	if in.Out.UseCache {
+		return in.Out, nil
+	}
+	dbOut, err := postgres.NewPostgreSQL(in.NodeSpec.DbInput)
+	if err != nil {
+		return nil, err
+	}
+	nodeOuts := make([]*clnode.Output, 0)
+	eg := &errgroup.Group{}
+	mu := &sync.Mutex{}
+	for i := 0; i < in.Nodes; i++ {
+		eg.Go(func() error {
+			net, err := clnode.NewNetworkCfgOneNetworkAllNodes(bcOut)
+			if err != nil {
+				return err
+			}
+			in.NodeSpec.Node.TestConfigOverrides = net
+			in.NodeSpec.DataProviderURL = fakeUrl
+			in.NodeSpec.Out = nil
+
+			dbURL := strings.Replace(dbOut.DockerInternalURL, "/chainlink?sslmode=disable", fmt.Sprintf("/db_%d?sslmode=disable", i), -1)
+			o, err := clnode.NewNode(in.NodeSpec, &postgres.Output{
+				Url:               dbOut.Url,
+				DockerInternalURL: dbURL,
+			})
+			if err != nil {
+				return err
+			}
+			mu.Lock()
+			nodeOuts = append(nodeOuts, o)
+			mu.Unlock()
+			return nil
+		})
+	}
+	if err := eg.Wait(); err != nil {
+		return nil, err
+	}
+	out := &Output{
+		UseCache: true,
+		CLNodes:  nodeOuts,
+	}
+	in.Out = out
+	return out, nil
+}