move CTFv1 to legacy

Author: skudasov

book/src/SUMMARY.md

@@ -103,12 +103,40 @@
       - [Debug Loki errors](./libs/wasp/how-to/debug_loki_errors.md)
     - [Havoc](./libs/havoc.md)
     - [Seth](./libs/seth.md)
-  - [AWS Secrets Manager]()
   - [Sentinel](./libs/sentinel.md)
 ---
 
-- [Legacy]()
+- [Legacy](./legacy.md)
   - [Overview](./legacy.md)
+  - [CTFv1](lib.md)
+      - [Blockchain](lib/blockchain.md)
+      - [Concurrency](lib/concurrency.md)
+      - [Client](lib/client.md)
+        - [Anvil]()
+        - [AWS Secrets Manager](lib/client/aws_secrets_manager.md)
+        - [Github](lib/client/github.md)
+        - [Grafana](lib/client/grafana.md)
+        - [Kafka](lib/client/kafka.md)
+        - [Loki](lib/client/loki.md)
+        - [MockServer](lib/client/mockserver.md)
+        - [Postgres](lib/client/postgres.md)
+        - [Prometheus](lib/client/prometheus.md)
+      - [Kubernetes](lib/k8s_new/overview.md)
+        - [Creating environments](lib/k8s_new/environments.md)
+        - [Using remote runner](lib/k8s_new/remote_runner.md)
+        - [Passing test secrets](lib/k8s_new/test_secrets.md)
+        - [chain.link labels](lib/k8s/labels.md)
+      - [Kubernetes (legacy docs)](lib/k8s/KUBERNETES.md)
+        - [K8s Remote Run](lib/k8s/REMOTE_RUN.md)
+        - [K8s Tutorial](lib/k8s/TUTORIAL.md)
+      - [Config](lib/config/config.md)
+      - [CRIB Connector](lib/crib.md)
+      - [Docker](lib/docker/overview.md)
+        - [Blockchain nodes](lib/docker/blockchain_nodes.md)
+        - [Chainlink ecosystem](lib/docker/chainlink_ecosystem.md)
+        - [Third party apps]()
+        - [Test helpers](lib/docker/test_helpers.md)
+      - [Logging](lib/logging.md)
   - [K8s Test Runner](k8s-test-runner/k8s-test-runner.md)
 
 ---

book/src/legacy.md

@@ -1,3 +1,3 @@
 # Legacy
 
-This chapter contains legacy documentation or code examples that will be sunset in the next release
+This chapter contains legacy documentation or code examples that will be sunset in the next major release

book/src/lib/blockchain.md

@@ -0,0 +1,45 @@
+# Blockchain Clients
+
+<div class="warning">
+
+This documentation is deprecated, we are using it in [Chainlink Integration Tests](https://github.com/smartcontractkit/chainlink/tree/develop/integration-tests)
+
+If you want to test our new products use [v2](../framework/overview.md)
+</div>
+
+This folder contains the bulk of code that handles integrating with different EVM chains. If you're looking to run tests on a new EVM chain, and are having issues with the default implementation, you've come to the right place.
+
+### Some Terminology
+
+- [L2 Chain](https://ethereum.org/en/layer-2/): A Layer 2 chain "branching" off Ethereum.
+- [EVM](https://ethereum.org/en/developers/docs/evm/): Ethereum Virtual Machine that underpins the Ethereum blockchain.
+- [EVM Compatible](https://blog.thirdweb.com/evm-compatible-blockchains-and-ethereum-virtual-machine/#:~:text=What%20does%20'EVM%20compatibility'%20mean,significant%20changes%20to%20their%20code.): A chain that has some large, underlying differences from how base Ethereum works, but can still be interacted with largely the same way as Ethereum.
+- [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559): The Ethereum Improvement Proposal that changed how gas fees are calculated and paid on Ethereum
+- Legacy Transactions: Transactions that are sent using the old gas fee calculation method, the one used before EIP-1559.
+- Dynamic Fee Transaction: Transactions that are sent using the new gas fee calculation method, the one used after EIP-1559.
+
+## How Client Integrations Work
+
+In order to test Chainlink nodes, the `chainlink-testing-framework` needs to be able to interact with the chain that the node is running on. This is done through the `blockchain.EVMClient` interface. The `EVMClient` interface is a wrapper around [geth](https://geth.ethereum.org/) to interact with the blockchain. We conduct all our testing blockchain operations through this wrapper, like sending transactions and monitoring on-chain events. The primary implementation of this wrapper is built for [Ethereum](./ethereum.go). Most others, like the [Metis](./metis.go) and [Optimism](./optimism.go) integrations, extend and modify the base Ethereum implementation.
+
+## Do I Need a New Integration?
+
+If you're reading this, probably. The default EVM integration is designed to work with mainnet Ethereum, which covers most other EVM chain interactions, but it's not guaranteed to work with all of them. If you're on a new chain and the test framework is throwing errors while doing basic things like send transactions, receive new headers, or deploy contracts, you'll likely need to create a new integration. The most common issue with new chains (especially L2s) is gas estimations and lack of support for dynamic transactions.
+
+## Creating a New Integration
+
+Take a look at the [Metis](./metis.go) integration as an example. Metis is an L2, EVM compatible chain. It's largely the same as the base Ethereum integration, so we'll extend from that.
+
+```go
+type MetisMultinodeClient struct {
+  *EthereumMultinodeClient
+}
+
+type MetisClient struct {
+  *EthereumClient
+}
+```
+
+Now we need to let other libraries (like our tests in the main Chainlink repo) that this integration exists. So we add the new implementation to the [known_networks.go](https://github.com/smartcontractkit/chainlink-testing-framework/blob/main/lib/blockchain/known_networks.go) file. We can then add that network to our tests' own [known_networks.go](https://github.com/smartcontractkit/chainlink/blob/develop/integration-tests/known_networks.go) file (it's annoying, there are plans to simplify).
+
+Now our Metis integration is the exact same as our base Ethereum one, which doesn't do us too much good. I'm assuming you came here to make some changes, so first let's find out what we need to change. This is a mix of reading developer documentation on the chain you're testing and trial and error. Mostly the latter in later stages. In the case of Metis, like many L2s, they [have their own spin on gas fees](https://docs.metis.io/dev/protocol-in-detail/transaction-fees-on-the-metis-platform). They also only support Legacy transactions. So we'll need to override any methods that deal with gas estimations, `Fund`, `DeployContract`, and `ReturnFunds`.

book/src/lib/client.md

@@ -0,0 +1,11 @@
+# Client
+
+We support a variety of clients that ease communication with following applications:
+* [Anvil](./client/anvil.md)
+* [AWS Secrets Manager](./client/aws_secrets_manager.md)
+* [Github](./client/github.md)
+* [Kafka](./client/kafka.md)
+* [Loki](./client/loki.md)
+* [MockServer](./client/mockserver.md)
+* [Postgres](./client/postgres.md)
+* [Prometheus](./client/prometheus.md)

book/src/lib/client/aws_secrets_manager.md

@@ -0,0 +1,33 @@
+# AWS Secrets Manager
+
+This simple client makes it even easier to:
+* read
+* create
+* remove secrets from AWS Secrets Manager.
+
+Creating a new instance is straight-forward. You should either use environment variables or shared configuration and credentials.
+
+> [!NOTE]
+> Environment variables take precedence over shared credentials.
+
+## Using environment variables
+You can pass required configuration as following environment variables:
+* `AWS_ACCESS_KEY_ID`
+* `AWS_SECRET_ACCESS_KEY`
+* `AWS_REGION`
+
+## Using shared credentials
+If you have shared credentials stored in `.aws/credentials` file, then the easiest way to configure the client is by setting
+`AWS_PROFILE` environment variable with the profile name. If that environment variable is not set, the SDK will try to use default profile.
+
+> [!WARNING]
+> Remember, that most probably you will need to manually create a new session for that profile before running your application.
+
+
+> [!NOTE]
+> You can read more about configuring the AWS SDK [here](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html).
+
+Once you have an instance of AWS Secrets Manager you gain access to following functions:
+* `CreateSecret(key string, val string, override bool) error`
+* `GetSecret(key string) (AWSSecret, error)`
+* `RemoveSecret(key string, noRecovery bool) error`

book/src/lib/client/github.md

@@ -0,0 +1,28 @@
+# Github
+
+This small client makes it easy to get `N` latest releases or tags from any Github.com repository. To use it, all you need to have
+is a properly scoped access token.
+
+```go
+publicRepoClient := NewGithubClient(WITHOUT_TOKEN)
+
+// "smartcontractkit", "chainlink"
+latestCLReleases, err := publicRepoClient.ListLatestCLCoreReleases(10)
+if err != nil {
+    panic(err)
+}
+
+// "smartcontractkit", "chainlink"
+latestCLTags, err := publicRepoClient.ListLatestCLCoreTags(10)
+if err != nil {
+    panic(err)
+}
+
+privateRepoClient := NewGithubClient("my-secret-PAT")
+myLatestReleases, err := privateRepoClient.ListLatestReleases("my-org", "my-private-repo", 5)
+if err != nil {
+    panic(err)
+}
+```
+
+There's really not much more to it...

book/src/lib/client/grafana.md

@@ -0,0 +1,80 @@
+# Grafana
+
+> [!NOTE]
+> Contrary to other clients, you will find Grafana client in a [separate package & go module](https://github.com/smartcontractkit/chainlink-testing-framework/tree/main/lib/grafana).
+
+Grafana client encapsulate following functionalities:
+* Dashboard creation
+* Managing dashboard annotations (CRUD)
+* Checking alerts
+
+# New instance
+In order to create a new instance you will need:
+* URL
+* API token
+
+For example:
+```go
+url := "http://grafana.io"
+apiToken := "such-a-secret-1&11n"
+gc := NewGrafanaClient(url, apiToken)
+```
+
+# Dashboard creation
+You can create a new dashboard defined in JSON with:
+```go
+
+//define your dashboard here
+dashboardJson := ``
+
+request := PostDashboardRequest {
+    Dashboard: dashboardJson,
+    FolderId: 5 // change to your folder id
+}
+
+dr, rawResponse, err := gc.PostDashboard(request)
+if err != nil {
+    panic(err)
+}
+
+if rawResponse.StatusCode() != 200 {
+    panic("response code wasn't 200, but " + rawResponse.StatusCode())
+}
+
+fmt.Println("Dashboard slug is is " + *dr.Slug)
+```
+
+# Posting annotations
+You can post annotations in a following way:
+```go
+annDetails := PostAnnotation {
+	DashboardUID: "some-uid",
+	Time:         time.Now(),
+	TimeEnd:      time.Now().Add(1 * time.Second)
+	Text:         "my test annotation"
+}
+
+r, rawResponse, err := gc.PostAnnotation(annDetails)
+if rawResponse.StatusCode() != 200 {
+    panic("response code wasn't 200, but " + rawResponse.StatusCode())
+}
+
+fmt.Println("Created annotation with id: " + r.Id)
+
+```
+
+# Checking alerts
+You can check alerts firing for a dashboard with UID:
+```go
+alerts, rawResponse, err := gc.AlertRulerClient.GetAlertsForDashboard("some-uid")
+if rawResponse.StatusCode() != 200 {
+    panic("response code wasn't 200, but " + rawResponse.StatusCode())
+}
+
+for name, value := range alerts {
+    fmt.Println("Alert named " + name + "was triggered. Details: " + string(value))
+}
+```
+
+# Troubleshooting
+To enable debug mode for the underlaying HTTP client set `RESTY_DEBUG` environment variable to `true`.

book/src/lib/client/kafka.md

@@ -0,0 +1,19 @@
+# Kafka
+
+This is a wrapper over HTTP client that can only return a list of topics from Kafka instance.
+
+```go
+client, err := NewKafkaRestClient(&NewKafkaRestClient{URL: "my-kafka-url"})
+if err != nil {
+    panic(err)
+}
+
+topis, err := client.GetTopics()
+if err != nil {
+    panic(err)
+}
+
+for _, topic := range topics {
+    fmt.Println("topic: " + topic)
+}
+```

book/src/lib/client/loki.md

@@ -0,0 +1,63 @@
+# Loki
+
+Loki client simplifies querying of Loki logs with `LogQL`.
+
+The way it's designed now implies that:
+* you need to create a new client instance for each query
+* query results are returned as `string`
+
+## New instance
+To create a new instance you to provide the following at the very least:
+* Loki URL
+* query to execute
+* time range
+
+```go
+// scheme is required
+lokiUrl := "http://loki-host.io"
+// can be empty
+tenantId := "promtail"
+basicAuth := LokiBasicAuth{
+    Login: "admin",
+    Password: "oh-so-secret",
+}
+queryParams := LokiQueryParams{
+				Query:     "quantile_over_time(0.5, {name='my awesome app'} | json| unwrap duration [10s]) by name",
+				StartTime: time.Now().Add(1 * time.Hour),
+				EndTime:   time.Now(),
+				Limit:     1000,
+}
+lokiClient := client.NewLokiClient(lokiUrl, tenantId, basicAuth, queryParams)
+```
+
+If your instance doesn't have basic auth you should use an empty string:
+```go
+basicAuth := LokiBasicAuth{}
+```
+
+## Executing a query
+Once you have the client instance created you can execute the query with:
+```go
+ctx, cancelFn := context.WithTimeout(context.Background, 3 * time.Minute)
+defer cancelFn()
+results, err := lokiClient.QueryLogs(ctx)
+if err != nil {
+    panic(err)
+}
+
+for _, logEntry := range results {
+    fmt.Println("At " + logEntry.Timestamp + " found following log: " + logEntry.Log)
+}
+```
+
+## Log entry types
+Loki can return various data types in responses to queries. We will try to convert the following ones to `string`:
+* `int`
+* `float64`
+
+If it's neither of these types nor a `string` the client will return an error. Same will happen if `nil` is returned.
+
+# Troubleshooting
+If you find yourself in trouble these two environment variables might help you:
+* `RESTY_DEBUG` set to `true` will enable debug mode for the underlaying HTTP client
+* `LOKI_CLIENT_LOG_LEVEL` controls log level of Loki client (for supported log levels check [logging package](../logging.md) documentation)