erigon-pulse/cmd/devnet/requests/request_generator.go
ledgerwatch c408281d3b
[devnet] separate logging (#7556)
Co-authored-by: Alex Sharp <alexsharp@Alexs-MacBook-Pro-2.local>
2023-05-20 21:57:32 +01:00

180 lines
5.3 KiB
Go

package requests
import (
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"time"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/log/v3"
"github.com/ledgerwatch/erigon/cmd/devnet/models"
"github.com/ledgerwatch/erigon/cmd/rpctest/rpctest"
)
func post(client *http.Client, url, request string, response interface{}, logger log.Logger) error {
start := time.Now()
r, err := client.Post(url, "application/json", strings.NewReader(request)) // nolint:bodyclose
if err != nil {
return fmt.Errorf("client failed to make post request: %v", err)
}
defer func(Body io.ReadCloser) {
closeErr := Body.Close()
if closeErr != nil {
logger.Warn("body close", "err", closeErr)
}
}(r.Body)
if r.StatusCode != 200 {
return fmt.Errorf("status %s", r.Status)
}
b, err := io.ReadAll(r.Body)
if err != nil {
return fmt.Errorf("failed to readAll from body: %s", err)
}
err = json.Unmarshal(b, &response)
if err != nil {
return fmt.Errorf("failed to unmarshal response: %s", err)
}
logger.Info("Got in", "time", time.Since(start).Seconds())
return nil
}
type RequestGenerator struct {
reqID int
client *http.Client
logger log.Logger
}
func (req *RequestGenerator) call(target string, method, body string, response interface{}) rpctest.CallResult {
start := time.Now()
err := post(req.client, models.ErigonUrl, body, response, req.logger)
return rpctest.CallResult{
RequestBody: body,
Target: target,
Took: time.Since(start),
RequestID: req.reqID,
Method: method,
Err: err,
}
}
func (req *RequestGenerator) Erigon(method models.RPCMethod, body string, response interface{}) rpctest.CallResult {
return req.call(models.ErigonUrl, string(method), body, response)
}
func (req *RequestGenerator) BlockNumber() string {
const template = `{"jsonrpc":"2.0","method":%q,"id":%d}`
return fmt.Sprintf(template, models.ETHBlockNumber, req.reqID)
}
func (req *RequestGenerator) GetAdminNodeInfo() string {
const template = `{"jsonrpc":"2.0","method":%q,"id":%d}`
return fmt.Sprintf(template, models.AdminNodeInfo, req.reqID)
}
func (req *RequestGenerator) GetBalance(address libcommon.Address, blockNum models.BlockNumber) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["0x%x","%v"],"id":%d}`
return fmt.Sprintf(template, models.ETHGetBalance, address, blockNum, req.reqID)
}
func (req *RequestGenerator) GetBlockByNumber(blockNum uint64, withTxs bool) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["0x%x",%t],"id":%d}`
return fmt.Sprintf(template, models.ETHGetBlockByNumber, blockNum, withTxs, req.reqID)
}
func (req *RequestGenerator) GetBlockByNumberI(blockNum string, withTxs bool) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["%s",%t],"id":%d}`
return fmt.Sprintf(template, models.ETHGetBlockByNumber, blockNum, withTxs, req.reqID)
}
func (req *RequestGenerator) GetLogs(fromBlock, toBlock uint64, address libcommon.Address) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":[{"fromBlock":"0x%x","toBlock":"0x%x","address":"0x%x"}],"id":%d}`
return fmt.Sprintf(template, models.ETHGetLogs, fromBlock, toBlock, address, req.reqID)
}
func (req *RequestGenerator) GetTransactionCount(address libcommon.Address, blockNum models.BlockNumber) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["0x%x","%v"],"id":%d}`
return fmt.Sprintf(template, models.ETHGetTransactionCount, address, blockNum, req.reqID)
}
func (req *RequestGenerator) SendRawTransaction(signedTx []byte) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["0x%x"],"id":%d}`
return fmt.Sprintf(template, models.ETHSendRawTransaction, signedTx, req.reqID)
}
func (req *RequestGenerator) TxpoolContent() string {
const template = `{"jsonrpc":"2.0","method":%q,"params":[],"id":%d}`
return fmt.Sprintf(template, models.TxpoolContent, req.reqID)
}
func (req *RequestGenerator) GetBlockDetails(blockNum string) string {
const template = `{"jsonrpc":"2.0","method":%q,"params":["%s"],"id":%d}`
return fmt.Sprintf(template, models.OTSGetBlockDetails, blockNum, req.reqID)
}
func (req *RequestGenerator) PingErigonRpc() rpctest.CallResult {
start := time.Now()
res := rpctest.CallResult{
RequestID: req.reqID,
}
// return early if the http module has issue fetching the url
resp, err := http.Get(models.ErigonUrl) //nolint
if err != nil {
res.Took = time.Since(start)
res.Err = err
return res
}
// close the response body after reading its content at the end of the function
defer func(body io.ReadCloser) {
closeErr := body.Close()
if closeErr != nil {
req.logger.Warn("failed to close readCloser", "err", closeErr)
}
}(resp.Body)
// return a bad request if the status code is not 200
if resp.StatusCode != 200 {
res.Took = time.Since(start)
res.Err = models.ErrBadRequest
return res
}
body, err := io.ReadAll(resp.Body)
if err != nil {
res.Took = time.Since(start)
res.Err = err
return res
}
res.Response = body
res.Took = time.Since(start)
res.Err = err
return res
}
func initialiseRequestGenerator(reqId int, logger log.Logger) *RequestGenerator {
var client = &http.Client{
Timeout: time.Second * 600,
}
reqGen := RequestGenerator{
client: client,
reqID: reqId,
logger: logger,
}
if reqGen.reqID == 0 {
reqGen.reqID++
}
return &reqGen
}