framework

const (
	EnvVarTestConfigs = "CTF_CONFIGS"
	//nolint
	EnvVarAWSSecretsManager = "CTF_AWS_SECRETS_MANAGER"
	// EnvVarCI this is a default env variable many CI runners use so code can detect we run in CI
	EnvVarCI = "CI"
)

const (
	DefaultConfigFilePath    = "env.toml"
	DefaultOverridesFilePath = "overrides.toml"
)

const (
	LocalGrafanaBaseURL    = "http://localhost:3000"
	LocalLokiBaseURL       = "http://localhost:3030"
	LocalPrometheusBaseURL = "http://localhost:9099"
	LocalPyroscopeBaseURL  = "http://localhost:4040"
	LocalCLNodeErrorsURL   = "http://localhost:3000/d/a7de535b-3e0f-4066-bed7-d505b6ec9ef1/cl-node-errors?orgId=1&refresh=5s"
	LocalWorkflowEngineURL = "http://localhost:3000/d/ce589a98-b4be-4f80-bed1-bc62f3e4414a/workflow-engine?orgId=1&refresh=5s&from=now-15m&to=now"
	LocalLogsURL           = "" /* 410-byte string literal not displayed */
	LocalPrometheusURL     = "" /* 350-byte string literal not displayed */
	LocalPostgresDebugURL  = "" /* 262-byte string literal not displayed */
	LocalPyroScopeURL      = "" /* 134-byte string literal not displayed */

	CTFObservabilityCacheDir      = ".local/share/ctf"
	CTFLocalDashboardsDirRelative = "dashboards"
)

const (
	// ProductDashboardUUID is a default product dashboard uuid, can be static since it's our local environment
	ProductDashboardUUID = "f8a04cef-653f-46d3-86df-87c532300672"

	ReadmeTmpl = `## Chainlink Developer Environment

This template provides a complete Chainlink development environment with pre-configured infrastructure and observability tools.

The goal of this local environment is to:
- Provide a simple and modular environment harness for developers to accelerate "inner" developer loop
- Implement standard functional system-level tests
- Implement standard non-functional system-level tests
- Implement standard 3rd party dependencies fakes so other teams can see your product requirements clearly

💻 Enter the shell to start:
` + "```" + `bash
just cli && {{ .CLIName }} sh
` + "```" + `

## Functional Testing

🔍 Implement your product configuration (see comnents in [configurator.go](./products/productone/configurator.go))

Add any additional product services using this [template](./services/svc.go)

Start the environment.
` + "```" + `bash
up ↵
` + "```" + `

🔍 Implement system-level functional tests [func_test.go](./tests/{{ .ProductName }}/func_test.go) and run them:
` + "```" + `bash
test func ↵
` + "```" + `

You can use ` + "`" + `restart ↵` + "`" + ` for quick iteration or ` + "`" + `{{ .CLIName }} r` + "`" + `

🔄 **Enforce** quality standards in CI: copy [workflow](.github/workflows/devenv-func-test.yml) to your CI folder, commit and make them pass

## Non-functional Testing

📈 Start the observability stack
` + "```" + `bash
obs u -f ↵
` + "```" + `

📈 Implement your product observability and [dashboard](http://localhost:3000/dashboards) (your dashboard is local/{{ .ProductName }} Services)
To reflect changes you can restart the environment and it'd be uploaded automatically from [dashboards](./dashboards/{{ .ProductName }}.json)

📈 Implement load/chaos tests [perf_test.go](./tests/{{ .ProductName }}/perf_test.go) and run them:
` + "```" + `bash
obs up -f ↵ # spin up the observability stack first
test perf ↵
` + "```" + `

You can use ` + "`" + `restart ↵` + "`" + ` for quick iteration or ` + "`" + `mycli r` + "`" + `
The same works for observability stack: ` + "`" + `obs r -f ↵` + "`" + ` or ` + "`" + `{{ .CLIName }} obs r -f` + "`" + `

We are using WASP load generator to make our tests composable and protocol agnostic, read more [here](https://smartcontractkit.github.io/chainlink-testing-framework/libs/wasp/overview.html?highlight=wasp#wasp---overview).

🔄 **Enforce** quality standards in CI: copy [workflow](.github/workflows/devenv-perf-test.yml) to your CI folder, commit and make them pass

## Fakes (HTTP)

To speed up development and integration with 3rd party services we have a "fakes" Docker container ready.

🔍 Implement [fakes](./fakes/main.go) for 3rd party services your need, rebuild the container and run:
` + "```" + `bash
just build-fakes
` + "```" + `

See how you can access your fake HTTP methods in [functional tests](./tests/{{ .ProductName }}/func_test.go)

## Running multiple instances of a product on a single environment

Just increase the amount of instances in [env.toml](./env.toml)
` + "```" + `bash
[[products]]
name = "{{ .ProductName }}"
instances = 20
` + "```" + `

Your implementation of ` + "`" + `ConfigureJobsAndContracts` + "`" + ` method should be able to deploy multiple instances.

You may use ` + "`" + `instanceIdx` + "`" + ` to run different deployments for each instance.


## Running multiple products in a single environment

Is simple, just copy [{{ .ProductName }}](./products/{{ .ProductName }})) and [tests/{{ .ProductName }}](./tests/{{ .ProductName }}) directories and add a new entry [here](./environment.go) in "newProduct" function.

## Adding more Node sets (DONs)

See [env.toml](./env.toml) comments.

`
	// ProductsInterfaceTmpl common interface for arbitrary products deployed in devenv
	ProductsInterfaceTmpl = `` /* 1860-byte string literal not displayed */

	// GoModTemplate go module template
	GoModTemplate = `` /* 725-byte string literal not displayed */

	// GitIgnoreTmpl default gitignore template
	GitIgnoreTmpl = `compose/
blockscout/
env-out.toml`

	// GrafanaDashboardTmpl is a Grafana dashboard template for your product
	GrafanaDashboardTmpl = `` /* 18430-byte string literal not displayed */

	// ConfigTOMLTmpl is a default env.toml template for devenv describind components configuration
	ConfigTOMLTmpl = `` /* 1132-byte string literal not displayed */

	// CINonFunctionalTmpl is a continuous integration template for end-to-end load/chaos tests
	CINonFunctionalTmpl = `` /* 2443-byte string literal not displayed */

	CIECRAuthActionTmpl = `` /* 1049-byte string literal not displayed */

	// CIFunctionalTmpl is a continuous integration template for end-to-end smoke tests
	CIFunctionalTmpl = `` /* 2469-byte string literal not displayed */

	// CompletionTmpl is a go-prompt library completion template providing interactive prompt
	CompletionTmpl = `` /* 5211-byte string literal not displayed */

	// CLITmpl is a Cobra library CLI template with basic devenv commands
	CLITmpl = `` /* 8258-byte string literal not displayed */

	// LoadTestTmpl is a load/chaos test template
	LoadTestTmpl = `` /* 3252-byte string literal not displayed */

	SmokeTestImplTmpl = `` /* 1136-byte string literal not displayed */

	// JDTmpl is a JobDistributor client wrappers
	JDTmpl = `` /* 1998-byte string literal not displayed */

	// DebugToolsTmpl is a template for various debug tools, tracing, tx debug, etc
	DebugToolsTmpl = `` /* 304-byte string literal not displayed */

	// ConfigTmpl is a template for reading and writing devenv configuration (env.toml, env-out.toml)
	ConfigTmpl = `` /* 3672-byte string literal not displayed */

	// EnvironmentTmpl is an environment.go template - main file for environment composition
	EnvironmentTmpl = `package {{ .PackageName }}

import (
	"context"
	"errors"
	"fmt"
	"os"
	"strings"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"

	"github.com/smartcontractkit/chainlink-testing-framework/framework"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/fake"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/jd"
	"github.com/smartcontractkit/{{ .ProductName }}/devenv/products/{{ .ProductName }}"
	"github.com/smartcontractkit/{{ .ProductName }}/devenv/services"

	ns "github.com/smartcontractkit/chainlink-testing-framework/framework/components/simple_node_set"
)

var L = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "{{ .ProductName }}"}).Logger()

type ProductInfo struct {
	Name      string ` + "`" + `toml:"name"` + "`" + `
	Instances int    ` + "`" + `toml:"instances"` + "`" + `
}

type Cfg struct {
	Products    []*ProductInfo      ` + "`" + `toml:"products"` + "`" + `
	Service     *services.ExampleSvcInput ` + "`" + `toml:"example_service"` + "`" + `
	Blockchains []*blockchain.Input ` + "`" + `toml:"blockchains" validate:"required"` + "`" + `
	FakeServer  *fake.Input         ` + "`" + `toml:"fake_server" validate:"required"` + "`" + `
	NodeSets    []*ns.Input         ` + "`" + `toml:"nodesets"    validate:"required"` + "`" + `
	JD          *jd.Input           ` + "`" + `toml:"jd"` + "`" + `
}

func newProduct(name string) (Product, error) {
	switch name {
	case "{{ .ProductName }}":
		return {{ .ProductName }}.NewConfigurator(), nil
	default:
		return nil, fmt.Errorf("unknown product type: %s", name)
	}
}

func NewEnvironment(ctx context.Context) error {
	if err := framework.DefaultNetwork(nil); err != nil {
		return err
	}
	in, err := Load[Cfg]()
	if err != nil {
		return fmt.Errorf("failed to load configuration: %w", err)
	}
	for _, bcNet := range in.Blockchains {
		_, err = blockchain.NewBlockchainNetwork(bcNet)
		if err != nil {
			return fmt.Errorf("failed to create blockchain network %s: %w", bcNet.ChainID, err)
		}
	}
	if os.Getenv("FAKE_SERVER_IMAGE") != "" {
		in.FakeServer.Image = os.Getenv("FAKE_SERVER_IMAGE")
	}
	_, err = fake.NewDockerFakeDataProvider(in.FakeServer)
	if err != nil {
		return fmt.Errorf("failed to create fake data provider: %w", err)
	}

	if err := services.NewService(in.Service); err != nil {
		return fmt.Errorf("failed to create example service: %w", err)
	}

	// get all the product orchestrations, generate product specific overrides
	productConfigurators := make([]Product, 0)
	nodeConfigs := make([]string, 0)
	nodeSecrets := make([]string, 0)
	for _, product := range in.Products {
		p, err := newProduct(product.Name)
		if err != nil {
			return err
		}
		if err = p.Load(); err != nil {
			return fmt.Errorf("failed to load product config: %w", err)
		}

		cfg, err := p.GenerateNodesConfig(ctx, in.FakeServer, in.Blockchains, in.NodeSets)
		if err != nil {
			return fmt.Errorf("failed to generate CL nodes config: %w", err)
		}
		nodeConfigs = append(nodeConfigs, cfg)

		secrets, err := p.GenerateNodesSecrets(ctx, in.FakeServer, in.Blockchains, in.NodeSets)
		if err != nil {
			return fmt.Errorf("failed to generate CL nodes config: %w", err)
		}
		nodeSecrets = append(nodeSecrets, secrets)

		productConfigurators = append(productConfigurators, p)
	}

	// merge overrides, spin up node sets and write infrastructure outputs
	// infra is always common for all the products, if it can't be we should fail
	// user should use different infra layout in env.toml then
	for _, nodeSet := range in.NodeSets {
		for _, nodeSpec := range nodeSet.NodeSpecs {
			nodeSpec.Node.TestConfigOverrides = strings.Join(nodeConfigs, "\n")
			nodeSpec.Node.TestSecretsOverrides = strings.Join(nodeSecrets, "\n")
			if os.Getenv("CHAINLINK_IMAGE") != "" {
				nodeSpec.Node.Image = os.Getenv("CHAINLINK_IMAGE")
			}
		}
		_, err = ns.NewSharedDBNodeSet(nodeSet, nil)
		if err != nil {
			return fmt.Errorf("failed to create new shared db node set: %w", err)
		}
	}
	if err := Store(in); err != nil {
		return err
	}

	// deploy all products and all instances,
	// product config function controls what to read and how to orchestrate each instance
	// via their own TOML part, we only deploy N instances of product M
	for productIdx, productInfo := range in.Products {
		for productInstance := range productInfo.Instances {
			err = productConfigurators[productIdx].ConfigureJobsAndContracts(
				ctx,
				productInstance,
				in.FakeServer,
				in.Blockchains,
				in.NodeSets,
			)
			if err != nil {
				return fmt.Errorf("failed to setup default product deployment: %w", err)
			}
			if err := productConfigurators[productIdx].Store("env-out.toml", productInstance); err != nil {
				return errors.New("failed to store product config")
			}
		}
	}
	for nsIdx, ns := range in.NodeSets {
		L.Info().Int("Idx", nsIdx).Str("Name", ns.Name).Msg("Created node set")
		for _, n := range ns.Out.CLNodes {
			L.Info().Str("Node", n.Node.ExternalURL).Send()
		}
	}
	return nil
}
`
	// JustFileTmpl is a Justfile template used for building and publishing Docker images
	JustFileTmpl = `` /* 311-byte string literal not displayed */

)

const (
	ProductSoakConfigTmpl = `` /* 272-byte string literal not displayed */

	ProductBasicConfigTmpl = `` /* 211-byte string literal not displayed */

	ProductsImplTmpl = `package {{ .ProductName }}

import (
	"context"
	"fmt"
	"os"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"

	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/fake"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/clclient"
	nodeset "github.com/smartcontractkit/chainlink-testing-framework/framework/components/simple_node_set"
	"github.com/smartcontractkit/{{ .ProductName }}/devenv/products"
)

/*
This is the implementation of your product configuration running on Chainlink platform.
*/

var L = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "{{ .ProductName }}"}).Logger()

// ProductConfig contains fields you want to be configurable for your product setup, don't forget to add "toml" annotations, use snake_case.
// Out field is mandatory if you want tests to read some data about your product.
type ProductConfig struct {
	Out *ProductConfigOutput ` + "`" + `toml:"out"` + "`" + `
}

// ProductConfigOutput contains fields that are exposed after your product is deployed,
// for example: contract addresses, services URLs, etc.
type ProductConfigOutput struct {
	ExampleField string ` + "`" + `toml:"example"` + "`" + `
}

// Configurator is your product configurator, it may contain configs for multiple instances of your product deployed on a single environment.
// For example, for soak/volume testing it makes sense to deploy 10-100 feeds with slightly different configurations to figure out performance and resource consumption.
type Configurator struct {
	Config []*ProductConfig ` + "`" + `toml:"{{ .ProductName }}"` + "`" + `
}

// NewConfigurator creates new configurator instance
func NewConfigurator() *Configurator {
	return &Configurator{}
}

// Load implements loading product-specific config from TOML file, see products/config.go
// Most of the time you don't need to change anything here.
func (m *Configurator) Load() error {
	cfg, err := products.Load[Configurator]()
	if err != nil {
		return fmt.Errorf("failed to load product config: %w", err)
	}
	m.Config = cfg.Config
	return nil
}

// Store implements storing your configuration outputs in "env-out.toml" file.
// You may store different outputs for each instance of your product (for example different outputs for each OCR feed when you deploy tens of them).
// Most of the time you don't need to change anything here.
func (m *Configurator) Store(path string, idx int) error {
	if err := products.Store(".", m); err != nil {
		return fmt.Errorf("failed to store product config: %w", err)
	}
	return nil
}

// GenerateNodesConfig implements how your product configures Chainlink nodes via TOML config
// Use Chainlink client from framework if needed and generate TOML config for Chainlink nodes.
func (m *Configurator) GenerateNodesConfig(
	ctx context.Context,
	fs *fake.Input,
	bc []*blockchain.Input,
	ns []*nodeset.Input,
) (string, error) {
	L.Info().Msg("Generating Chainlink node config")
	// in this case we have only a single node set
	firstNodeSet := ns[0]
	_ = firstNodeSet

	// in this case we only have a single blockchain type
	firstBlockchain := bc[0]

	// environment config for CL nodes
	_ = firstBlockchain.Out.Nodes[0]
	// chain ID
	_ = firstBlockchain.Out.ChainID
	return "", nil
}

func (m *Configurator) GenerateNodesSecrets(
	ctx context.Context,
	fs *fake.Input,
	bc []*blockchain.Input,
	ns []*nodeset.Input,
) (string, error) {
	L.Info().Msg("Generating Chainlink node secrets")
	// in this case we only have a single blockchain type
	firstBlockchain := bc[0]
	// blockchain info for blockchain 0 and node 0
	_ = firstBlockchain.Out.Nodes[0]
	// chain ID for blockchain 0
	_ = firstBlockchain.Out.ChainID
	return "", nil
}

func (m *Configurator) ConfigureJobsAndContracts(
	ctx context.Context,
	productIdx int,
	fake *fake.Input,
	bc []*blockchain.Input,
	ns []*nodeset.Input,
) error {
	// in this case we have only a single node set
	firstNodeSet := ns[0]
	// connect to Chainlink nodes and use the client to get keys and other data if needed
	cl, err := clclient.New(firstNodeSet.Out.CLNodes)
	if err != nil {
		return err
	}
	_ = cl

	// write an example output of your product configuration
	// contract addresses, URLs, etc
	// in soak test case it may hold multiple configs and have different outputs
	// for each instance
	m.Config[0].Out = &ProductConfigOutput{ExampleField: "my_data"}
	L.Info().Msg("Configuring product: {{ .ProductName }}")
	return nil
}
`

	ProductsConfigTmpl = `` /* 2435-byte string literal not displayed */

	ProductsCommonTmpl = `` /* 4951-byte string literal not displayed */

)

const (
	ProductFakesJustfile = `` /* 708-byte string literal not displayed */

	ProductFakesImplTmpl = `` /* 700-byte string literal not displayed */

	ProductFakesGoModuleTmpl = `` /* 363-byte string literal not displayed */

	ProductFakesDockerfileTmpl = `` /* 314-byte string literal not displayed */

)

const (
	CISummaryFile = "ci_summary.txt"
)

const (
	DefaultCTFLogsDir = "logs/docker"
)

const (
	DefaultConfigDir = "."
)

const (
	EnvVarIgnoreCriticalLogs = "CTF_IGNORE_CRITICAL_LOGS"
)

const (
	EnvVarLogLevel = "CTF_LOG_LEVEL"
)

const (
	ProductComponentImpl = `
	package services

/*
 * A simple template to add your project services to devenv.
 * Each service should have a file with Input/Output struct and a function deploying it.
 */

import (
		"context"
		"fmt"
		"os"
		"strconv"

		"github.com/rs/zerolog"
		"github.com/rs/zerolog/log"

		"github.com/docker/docker/api/types/container"
		"github.com/docker/go-connections/nat"
		"github.com/smartcontractkit/chainlink-testing-framework/framework"
		"github.com/testcontainers/testcontainers-go"
)

var L = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "datastreams"}).Logger()

const (
		DefaultExampleSvcName  = "example-service"
		DefaultExampleSvcImage = "busybox:latest"
)

// ExampleSvcInput example service input
type ExampleSvcInput struct {
		Image         string            ` + "`" + `toml:"image"` + "`" + `
		Port          int               ` + "`" + `toml:"port"` + "`" + `
		ContainerName string            ` + "`" + `toml:"container_name"` + "`" + `
		EnvVars       map[string]string ` + "`" + `toml:"env_vars"` + "`" + `
		Out           *ExampleSvcOutput ` + "`" + `toml:"out"` + "`" + `
}

// Default is a default input configuration
func (s *ExampleSvcInput) Default() {
		if s.Image == "" {
			s.Image = DefaultExampleSvcImage
		}
		if s.Port == 0 {
			s.Port = 9501
		}
		if s.ContainerName == "" {
			s.ContainerName = DefaultExampleSvcName
		}
}

// ExampleSvcOutput represents service connection details which can be consumed by tests
// or environment.go, or any other metadata your need to expose to clients
type ExampleSvcOutput struct {
		ServiceURL string ` + "`" + `toml:"service_url"` + "`" + `
}

// NewService deploys an example service and populates output data
func NewService(in *ExampleSvcInput) error {
		if in == nil || in.Out != nil {
			// either service key is not present in configuration
			// or it is already deployed because we have an output, skipping
			L.Info().Str("ServiceName", DefaultExampleSvcName).Msg("service is skipped or already deployed")
			return nil
		}
		ctx := context.Background()
		// read and apply default inputs
		in.Default()
		// create your service container, use static ports
		req := testcontainers.ContainerRequest{
			Image:    in.Image,
			Name:     in.ContainerName,
			Labels:   framework.DefaultTCLabels(),
			Networks: []string{framework.DefaultNetworkName},
			NetworkAliases: map[string][]string{
				framework.DefaultNetworkName: {in.ContainerName},
			},
			Env: in.EnvVars,
			Cmd: []string{"sleep", "infinity"},
			// add more internal ports here with /tcp suffix, ex.: 9501/tcp
			ExposedPorts: []string{"9501/tcp"},
			HostConfigModifier: func(h *container.HostConfig) {
				h.PortBindings = nat.PortMap{
					// add more internal/external pairs here, ex.: 9501/tcp as a key and HostPort is the exposed port (no /tcp prefix!)
					"9501/tcp": []nat.PortBinding{
						{HostPort: strconv.Itoa(in.Port)},
					},
				}
			},
			// for complex services wait for specific log message
			// WaitingFor: wait.ForLog("Some log message").
			// 	WithStartupTimeout(120 * time.Second).
			// 	WithPollInterval(3 * time.Second),
		}
		_, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
			ContainerRequest: req,
			Started:          true,
		})
		if err != nil {
			return fmt.Errorf("failed to setup %s service", in.ContainerName)
		}

		// write outputs on a shared struct
		in.Out = &ExampleSvcOutput{
			ServiceURL: "https://example.com",
		}
		return nil
}
	`
)