main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"sort"
	"sync"
	"time"

	"github.com/fatih/color"
)

type Config struct {
	Method       string      `json:"method"`
	URL          string      `json:"url"`
	RequestBody  interface{} `json:"requestBody"`
	RequestCount int         `json:"requestCount"`

	Authorization    string `json:"authorization"`
	ShowResponseBody bool   `json:"showResponseBody"`
	Timeout          int    `json:"timeout"`
}

type Result struct {
	ID           int
	Method       string
	URL          string
	StatusCode   int
	ResponseBody string
	Err          error
}

var (
	configFile string
	config     Config
	results    []Result
	mu         sync.Mutex
)

func init() {
	flag.StringVar(&configFile, "config", "", "Path to YAML configuration file")
}

func main() {
	flag.Parse()

	if configFile == "" {
		log.Fatal("Configuration file is required")
	}

	err := loadConfig(configFile, &config)
	if err != nil {
		log.Fatalf("Error loading config: %v\n", err)
	}

	client := &http.Client{
		Timeout:   time.Duration(config.Timeout) * time.Second,
		Transport: &http.Transport{MaxConnsPerHost: 50},
	}

	var wg sync.WaitGroup
	wg.Add(config.RequestCount)

	for i := 1; i < config.RequestCount+1; i++ {
		go func(i int) {
			defer wg.Done()
			sendRequest(client, i)
		}(i)
	}

	wg.Wait()

	sortResults()
	printResults()
}

func loadConfig(filename string, config *Config) error {
	data, err := os.ReadFile(filename)
	if err != nil {
		return err
	}

	err = json.Unmarshal(data, config)
	if err != nil {
		return err
	}

	return nil
}

func sendRequest(client *http.Client, id int) {
	// requestBody := bytes.NewBuffer([]byte(fmt.Sprintf("%v", config.RequestBody)))
	request, err := http.NewRequest(config.Method, config.URL, nil)
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", config.Authorization)

	response, err := client.Do(request)

	if err != nil {
		storeResult(Result{ID: id, Method: config.Method, URL: config.URL, Err: err})
		return
	}
	defer response.Body.Close()

	var bodyStr string
	if config.ShowResponseBody {
		body, err := io.ReadAll(response.Body)
		if err != nil {
			storeResult(Result{ID: id, Method: config.Method, URL: config.URL, StatusCode: response.StatusCode, Err: err})
			return
		}
		bodyStr = string(body)
	}

	storeResult(Result{ID: id, Method: config.Method, URL: config.URL, StatusCode: response.StatusCode, ResponseBody: bodyStr})
}

func storeResult(result Result) {
	mu.Lock()
	results = append(results, result)
	mu.Unlock()
}

func sortResults() {
	sort.Slice(results, func(i, j int) bool {
		return results[i].ID < results[j].ID
	})
}

func printResults() {
	for _, result := range results {
		if result.Err != nil {
			color.Red("Request %d failed: %v\n", result.ID, result.Err)
		} else {
			switch {
			case result.StatusCode >= 200 && result.StatusCode < 300:
				color.Green("%d: [%s] %s, %d\n", result.ID, result.Method, result.URL, result.StatusCode)
			case result.StatusCode >= 300 && result.StatusCode < 400:
				color.Yellow("%d: [%s] %s, %d\n", result.ID, result.Method, result.URL, result.StatusCode)
			case result.StatusCode >= 400 && result.StatusCode < 600:
				color.Red("%d: [%s] %s, %d\n", result.ID, result.Method, result.URL, result.StatusCode)
			default:
				color.White("%d: [%s] %s, %d\n", result.ID, result.Method, result.URL, result.StatusCode)
			}
		}

		if config.ShowResponseBody && result.ResponseBody != "" {
			fmt.Println(result.ResponseBody)
		}
	}
}