Merge pull request #112 from aykhans/core/refactor-clients

🔧 Update client configs to skip connection verification if it is not secure

.github/workflows/golangci-lint.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           go-version: stable
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v7
         with:
-          version: v1.64
+          version: v2.0.2
           args: --timeout=10m --config=.golangci.yml

.golangci.yml

@@ -1,16 +1,16 @@
+version: "2"
+
 run:
     go: "1.24"
     concurrency: 8
     timeout: 10m
 
 linters:
-    disable-all: true
+    default: none
     enable:
         - asasalint
         - asciicheck
         - errcheck
-        - gofmt
-        - goimports
         - gomodguard
         - goprintffuncname
         - govet
@@ -21,7 +21,13 @@ linters:
         - prealloc
         - reassign
         - staticcheck
-        - typecheck
         - unconvert
         - unused
         - whitespace
+
+    settings:
+        staticcheck:
+            checks:
+                - "all"
+                - "-S1002"
+                - "-ST1000"

Dockerfile

@@ -7,13 +7,11 @@ RUN go mod download
 COPY . .
 
 RUN go build -ldflags "-s -w" -o dodo
-RUN echo "{}" > config.json
 
 FROM gcr.io/distroless/static-debian12:latest
 
 WORKDIR /
 
 COPY --from=builder /src/dodo /dodo
-COPY --from=builder /src/config.json /config.json
 
-ENTRYPOINT ["./dodo", "-f", "/config.json"]
+ENTRYPOINT ["./dodo"]

Makefile

@@ -1,9 +0,0 @@
-lint:
-	golangci-lint run
-
-build:
-	go build -ldflags "-s -w" -o "./dodo"
-
-build-all:
-	rm -rf ./binaries
-	./build.sh

README.md

@@ -3,78 +3,77 @@
 <img width="30%" height="30%" src="https://ftp.aykhans.me/web/client/pubshares/VzPtSHS7yPQT7ngoZzZSNU/browse?path=%2Fdodo.png">
 </p>
 
+## Table of Contents
+
+- [Installation](#installation)
+    - [Using Docker (Recommended)](#using-docker-recommended)
+    - [Using Pre-built Binaries](#using-pre-built-binaries)
+    - [Building from Source](#building-from-source)
+- [Usage](#usage)
+    - [1. CLI Usage](#1-cli-usage)
+    - [2. Config File Usage](#2-config-file-usage)
+        - [2.1 JSON Example](#21-json-example)
+        - [2.2 YAML/YML Example](#22-yamlyml-example)
+    - [3. CLI & Config File Combination](#3-cli--config-file-combination)
+- [Config Parameters Reference](#config-parameters-reference)
+
 ## Installation
 
 ### Using Docker (Recommended)
 
-Pull the Dodo image from Docker Hub:
+Pull the latest Dodo image from Docker Hub:
 
 ```sh
 docker pull aykhans/dodo:latest
 ```
 
-When using Dodo with Docker and a local config file, you must provide the config.json file as a volume to the Docker run command (not as the "-f config.json" argument):
+To use Dodo with Docker and a local config file, mount the config file as a volume and pass it as an argument:
 
 ```sh
-docker run -v /path/to/config.json:/config.json aykhans/dodo
+docker run -v /path/to/config.json:/config.json aykhans/dodo -f /config.json
 ```
 
-If you're using Dodo with Docker and providing a config file via URL, you don't need to set a volume:
+If you're using a remote config file via URL, you don't need to mount a volume:
 
 ```sh
-docker run aykhans/dodo -f https://raw.githubusercontent.com/aykhans/dodo/main/config.json
+docker run aykhans/dodo -f https://raw.githubusercontent.com/aykhans/dodo/main/config.yaml
 ```
 
-### Using Binary Files
+### Using Pre-built Binaries
 
-You can download pre-built binaries from the [releases](https://github.com/aykhans/dodo/releases) section.
+Download the latest binaries from the [releases](https://github.com/aykhans/dodo/releases) section.
 
 ### Building from Source
 
-To build Dodo from source, you need to have [Go 1.24+](https://golang.org/dl/) installed.
+To build Dodo from source, ensure you have [Go 1.24+](https://golang.org/dl/) installed.
-Follow these steps:
 
-1. **Clone the repository:**
+```sh
-
+go install -ldflags "-s -w" github.com/aykhans/dodo@latest
-    ```sh
+```
-    git clone https://github.com/aykhans/dodo.git
-    ```
-
-2. **Navigate to the project directory:**
-
-    ```sh
-    cd dodo
-    ```
-
-3. **Build the project:**
-
-    ```sh
-    go build -ldflags "-s -w" -o dodo
-    ```
-
-This will generate an executable named `dodo` in the project directory.
 
 ## Usage
 
-You can use Dodo with CLI arguments, a JSON config file, or both. When using both, CLI arguments will override JSON config values if there's a conflict.
+Dodo supports CLI arguments, configuration files (JSON/YAML), or a combination of both. If both are used, CLI arguments take precedence.
 
-### 1. CLI
+### 1. CLI Usage
 
-Send 1000 GET requests to https://example.com with 10 parallel dodos (threads) and a timeout of 2 seconds:
+Send 1000 GET requests to https://example.com with 10 parallel dodos (threads), each with a timeout of 2 seconds, within a maximum duration of 1 minute:
 
 ```sh
-dodo -u https://example.com -m GET -d 10 -r 1000 -t 2s
+dodo -u https://example.com -m GET -d 10 -r 1000 -o 1m -t 2s
 ```
 
 With Docker:
 
 ```sh
-docker run --rm -i aykhans/dodo -u https://example.com -m GET -d 10 -r 1000 -t 2s
+docker run --rm -i aykhans/dodo -u https://example.com -m GET -d 10 -r 1000 -o 1m -t 2s
 ```
 
-### 2. JSON Config File
+### 2. Config File Usage
 
-Send 1000 GET requests to https://example.com with 10 parallel dodos (threads) and a timeout of 800 milliseconds:
+Send 1000 GET requests to https://example.com with 10 parallel dodos (threads), each with a timeout of 800 milliseconds, within a maximum duration of 250 seconds:
+
+#### 2.1 JSON Example
 
 ```jsonc
 {
@@ -84,6 +83,7 @@ Send 1000 GET requests to https://example.com with 10 parallel dodos (threads) a
     "timeout": "800ms",
     "dodos": 10,
     "requests": 1000,
+    "duration": "250s",
 
     "params": [
         // A random value will be selected from the list for first "key1" param on each request
@@ -152,35 +152,112 @@ docker run --rm -i -v /path/to/config.json:/config.json aykhans/dodo
 docker run --rm -i aykhans/dodo -f https://example.com/config.json
 ```
 
-### 3. Combined (CLI & JSON)
+#### 2.2 YAML/YML Example
 
-Override the config file arguments with CLI arguments:
+```yaml
+method: "GET"
+url: "https://example.com"
+yes: false
+timeout: "800ms"
+dodos: 10
+requests: 1000
+duration: "250s"
+
+params:
+    # A random value will be selected from the list for first "key1" param on each request
+    # And always "value" for second "key1" param on each request
+    # e.g. "?key1=value2&key1=value"
+    - key1: ["value1", "value2", "value3", "value4"]
+    - key1: "value"
+
+    # A random value will be selected from the list for param "key2" on each request
+    # e.g. "?key2=value2"
+    - key2: ["value1", "value2"]
+
+headers:
+    # A random value will be selected from the list for first "key1" header on each request
+    # And always "value" for second "key1" header on each request
+    # e.g. "key1: value3", "key1: value"
+    - key1: ["value1", "value2", "value3", "value4"]
+    - key1: "value"
+
+    # A random value will be selected from the list for header "key2" on each request
+    # e.g. "key2: value2"
+    - key2: ["value1", "value2"]
+
+cookies:
+    # A random value will be selected from the list for first "key1" cookie on each request
+    # And always "value" for second "key1" cookie on each request
+    # e.g. "key1=value4; key1=value"
+    - key1: ["value1", "value2", "value3", "value4"]
+    - key1: "value"
+
+    # A random value will be selected from the list for cookie "key2" on each request
+    # e.g. "key2=value1"
+    - key2: ["value1", "value2"]
+
+body: "body-text"
+# OR
+# A random body value will be selected from the list for each request
+body:
+    - "body-text1"
+    - "body-text2"
+    - "body-text3"
+
+proxy: "http://example.com:8080"
+# OR
+# A random proxy will be selected from the list for each request
+proxy:
+    - "http://example.com:8080"
+    - "http://username:password@example.com:8080"
+    - "socks5://example.com:8080"
+    - "socks5h://example.com:8080"
+```
 
 ```sh
-dodo -f /path/to/config.json -u https://example.com -m GET -d 10 -r 1000 -t 5s
+dodo -f /path/config.yaml
+# OR
+dodo -f https://example.com/config.yaml
 ```
 
 With Docker:
 
 ```sh
-docker run --rm -i -v /path/to/config.json:/config.json aykhans/dodo -u https://example.com -m GET -d 10 -r 1000 -t 5s
+docker run --rm -i -v /path/to/config.yaml:/config.yaml aykhans/dodo -f /config.yaml
+# OR
+docker run --rm -i aykhans/dodo -f https://example.com/config.yaml
 ```
 
-## CLI and JSON Config Parameters
+### 3. CLI & Config File Combination
+
+CLI arguments override config file values:
+
+```sh
+dodo -f /path/to/config.yaml -u https://example.com -m GET -d 10 -r 1000 -o 1m -t 5s
+```
+
+With Docker:
+
+```sh
+docker run --rm -i -v /path/to/config.json:/config.json aykhans/dodo -f /config.json -u https://example.com -m GET -d 10 -r 1000 -o 1m -t 5s
+```
+
+## Config Parameters Reference
 
 If `Headers`, `Params`, `Cookies`, `Body`, or `Proxy` fields have multiple values, each request will choose a random value from the list.
 
-| Parameter       | JSON config file | CLI Flag     | CLI Short Flag | Type                           | Description                                                     | Default |
+| Parameter       | config file | CLI Flag     | CLI Short Flag | Type                           | Description                                                 | Default |
-| --------------- | ---------------- | ------------ | -------------- | ------------------------------ | --------------------------------------------------------------- | ------- |
+| --------------- | ----------- | ------------ | -------------- | ------------------------------ | ----------------------------------------------------------- | ------- |
-| Config file     | -                | -config-file | -f             | String                         | Path to local config file or http(s) URL of the config file     | -       |
+| Config file     | -           | -config-file | -f             | String                         | Path to local config file or http(s) URL of the config file | -       |
-| Yes             | yes              | -yes         | -y             | Boolean                        | Answer yes to all questions                                     | false   |
+| Yes             | yes         | -yes         | -y             | Boolean                        | Answer yes to all questions                                 | false   |
-| URL             | url              | -url         | -u             | String                         | URL to send the request to                                      | -       |
+| URL             | url         | -url         | -u             | String                         | URL to send the request to                                  | -       |
-| Method          | method           | -method      | -m             | String                         | HTTP method                                                     | GET     |
+| Method          | method      | -method      | -m             | String                         | HTTP method                                                 | GET     |
-| Requests        | requests         | -requests    | -r             | UnsignedInteger                | Total number of requests to send                                | 1000    |
+| Dodos (Threads) | dodos       | -dodos       | -d             | UnsignedInteger                | Number of dodos (threads) to send requests in parallel      | 1       |
-| Dodos (Threads) | dodos            | -dodos       | -d             | UnsignedInteger                | Number of dodos (threads) to send requests in parallel          | 1       |
+| Requests        | requests    | -requests    | -r             | UnsignedInteger                | Total number of requests to send                            | -       |
-| Timeout         | timeout          | -timeout     | -t             | Duration                       | Timeout for canceling each request                              | 10s     |
+| Duration        | duration    | -duration    | -o             | Time                           | Maximum duration for the test                               | -       |
-| Params          | params           | -param       | -p             | [{String: String OR [String]}] | Request parameters                                              | -       |
+| Timeout         | timeout     | -timeout     | -t             | Time                           | Timeout for canceling each request                          | 10s     |
-| Headers         | headers          | -header      | -H             | [{String: String OR [String]}] | Request headers                                                 | -       |
+| Params          | params      | -param       | -p             | [{String: String OR [String]}] | Request parameters                                          | -       |
-| Cookies         | cookies          | -cookie      | -c             | [{String: String OR [String]}] | Request cookies                                                 | -       |
+| Headers         | headers     | -header      | -H             | [{String: String OR [String]}] | Request headers                                             | -       |
-| Body            | body             | -body        | -b             | String OR [String]             | Request body or list of request bodies                          | -       |
+| Cookies         | cookies     | -cookie      | -c             | [{String: String OR [String]}] | Request cookies                                             | -       |
-| Proxy           | proxies          | -proxy       | -x             | String OR [String]             | Proxy URL or list of proxy URLs                                 | -       |
+| Body            | body        | -body        | -b             | String OR [String]             | Request body or list of request bodies                      | -       |
+| Proxy           | proxies     | -proxy       | -x             | String OR [String]             | Proxy URL or list of proxy URLs                             | -       |

Taskfile.yaml

@@ -0,0 +1,45 @@
+# https://taskfile.dev
+
+version: "3"
+
+vars:
+    PLATFORMS:
+        - os: darwin
+          archs: [amd64, arm64]
+        - os: freebsd
+          archs: [386, amd64, arm]
+        - os: linux
+          archs: [386, amd64, arm, arm64]
+        - os: netbsd
+          archs: [386, amd64, arm]
+        - os: openbsd
+          archs: [386, amd64, arm, arm64]
+        - os: windows
+          archs: [386, amd64, arm64]
+
+tasks:
+    run: go run main.go
+
+    fmt: gofmt -w -d .
+
+    lint: golangci-lint run
+
+    build: go build -ldflags "-s -w" -o "dodo"
+
+    build-all:
+        silent: true
+        cmds:
+            - rm -rf binaries
+            - |
+                {{ $ext := "" }}
+                {{- range $platform := .PLATFORMS }}
+                    {{- if eq $platform.os "windows" }}
+                        {{ $ext = ".exe" }}
+                    {{- end }}
+
+                    {{- range $arch := $platform.archs }}
+                        echo "Building for {{$platform.os}}/{{$arch}}"
+                        GOOS={{$platform.os}} GOARCH={{$arch}} go build -ldflags "-s -w" -o "./binaries/dodo-{{$platform.os}}-{{$arch}}{{$ext}}"
+                    {{- end }}
+                {{- end }}
+            - echo -e "\033[32m*** Build completed ***\033[0m"

build.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-
-platforms=(
-    "darwin,amd64"
-    "darwin,arm64"
-    "freebsd,386"
-    "freebsd,amd64"
-    "freebsd,arm"
-    "linux,386"
-    "linux,amd64"
-    "linux,arm"
-    "linux,arm64"
-    "netbsd,386"
-    "netbsd,amd64"
-    "netbsd,arm"
-    "openbsd,386"
-    "openbsd,amd64"
-    "openbsd,arm"
-    "openbsd,arm64"
-    "windows,386"
-    "windows,amd64"
-    "windows,arm64"
-)
-
-for platform in "${platforms[@]}"; do
-    IFS=',' read -r build_os build_arch <<< "$platform"
-    ext=""
-    if [ "$build_os" == "windows" ]; then
-        ext=".exe"
-    fi
-    GOOS="$build_os" GOARCH="$build_arch" go build -ldflags "-s -w" -o "./binaries/dodo-$build_os-$build_arch$ext"
-done

config.json

@@ -5,6 +5,7 @@
     "timeout": "5s",
     "dodos": 8,
     "requests": 1000,
+    "duration": "10s",
 
     "params": [
         { "key1": ["value1", "value2", "value3", "value4"] },

config.yaml

@@ -1,12 +1,10 @@
-# YAML/YML config file option is not implemented yet.
-# This file is a example for future implementation.
-
 method: "GET"
 url: "https://example.com"
 yes: false
 timeout: "5s"
-dodos: 10
+dodos: 8
 requests: 1000
+duration: "10s"
 
 params:
     - key1: ["value1", "value2", "value3", "value4"]
@@ -25,6 +23,7 @@ cookies:
 
 # body: "body-text"
 # OR
+# A random body value will be selected from the list for each request
 body:
     - "body-text1"
     - "body-text2"
@@ -32,6 +31,7 @@ body:
 
 # proxy: "http://example.com:8080"
 # OR
+# A random proxy will be selected from the list for each request
 proxy:
     - "http://example.com:8080"
     - "http://username:password@example.com:8080"

config/cli.go

@@ -16,8 +16,8 @@ const cliUsageText = `Usage:
 
 Examples:
 
-Simple usage only with URL:
+Simple usage:
-  dodo -u https://example.com
+  dodo -u https://example.com -o 1m
 
 Usage with config file:
   dodo -f /path/to/config/file/config.json
@@ -25,7 +25,7 @@ Usage with config file:
 Usage with all flags:
   dodo -f /path/to/config/file/config.json \
     -u https://example.com -m POST \
-    -d 10 -r 1000 -t 3s \
+    -d 10 -r 1000 -o 3m -t 3s \
     -b "body1" -body "body2" \
     -H "header1:value1" -header "header2:value2" \
     -p "param1=value1" -param "param2=value2" \
@@ -39,13 +39,14 @@ Flags:
   -y, -yes          bool      Answer yes to all questions (default %v)
   -f, -config-file  string    Path to the local config file or http(s) URL of the config file
   -d, -dodos        uint      Number of dodos(threads) (default %d)
-  -r, -requests     uint      Number of total requests (default %d)
+  -r, -requests     uint      Number of total requests
-  -t, -timeout      Duration  Timeout for each request (e.g. 400ms, 15s, 1m10s) (default %v)
+  -o, -duration     Time      Maximum duration for the test (e.g. 30s, 1m, 5h)
+  -t, -timeout      Time      Timeout for each request (e.g. 400ms, 15s, 1m10s) (default %v)
   -u, -url          string    URL for stress testing
   -m, -method       string    HTTP Method for the request (default %s)
   -b, -body         [string]  Body for the request (e.g. "body text")
   -p, -param        [string]  Parameter for the request (e.g. "key1=value1")
-  -H, -header       [string]  Header for the request (e.g. "key1: value1")
+  -H, -header       [string]  Header for the request (e.g. "key1:value1")
   -c, -cookie       [string]  Cookie for the request (e.g. "key1=value1")
   -x, -proxy        [string]  Proxy for the request (e.g. "http://proxy.example.com:8080")`
 
@@ -55,7 +56,6 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 			cliUsageText+"\n",
 			DefaultYes,
 			DefaultDodosCount,
-			DefaultRequestCount,
 			DefaultTimeout,
 			DefaultMethod,
 		)
@@ -70,6 +70,7 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 		dodosCount   = uint(0)
 		requestCount = uint(0)
 		timeout      time.Duration
+		duration     time.Duration
 	)
 
 	{
@@ -94,6 +95,9 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 		flag.UintVar(&requestCount, "requests", 0, "Number of total requests")
 		flag.UintVar(&requestCount, "r", 0, "Number of total requests")
 
+		flag.DurationVar(&duration, "duration", 0, "Maximum duration of the test")
+		flag.DurationVar(&duration, "o", 0, "Maximum duration of the test")
+
 		flag.DurationVar(&timeout, "timeout", 0, "Timeout for each request (e.g. 400ms, 15s, 1m10s)")
 		flag.DurationVar(&timeout, "t", 0, "Timeout for each request (e.g. 400ms, 15s, 1m10s)")
 
@@ -139,6 +143,8 @@ func (config *Config) ReadCLI() (types.ConfigFile, error) {
 			config.DodosCount = utils.ToPtr(dodosCount)
 		case "requests", "r":
 			config.RequestCount = utils.ToPtr(requestCount)
+		case "duration", "o":
+			config.Duration = &types.Duration{Duration: duration}
 		case "timeout", "t":
 			config.Timeout = &types.Timeout{Duration: timeout}
 		case "yes", "y":

config/config.go

@@ -15,29 +15,31 @@ import (
 )
 
 const (
-	VERSION             string        = "0.6.0"
+	VERSION             string        = "0.6.4"
 	DefaultUserAgent    string        = "Dodo/" + VERSION
 	DefaultMethod       string        = "GET"
 	DefaultTimeout      time.Duration = time.Second * 10
 	DefaultDodosCount   uint          = 1
-	DefaultRequestCount uint          = 1
+	DefaultRequestCount uint          = 0
+	DefaultDuration     time.Duration = 0
 	DefaultYes          bool          = false
 )
 
 var SupportedProxySchemes []string = []string{"http", "socks5", "socks5h"}
 
 type RequestConfig struct {
-	Method       string        `json:"method"`
+	Method       string
-	URL          url.URL       `json:"url"`
+	URL          url.URL
-	Timeout      time.Duration `json:"timeout"`
+	Timeout      time.Duration
-	DodosCount   uint          `json:"dodos"`
+	DodosCount   uint
-	RequestCount uint          `json:"requests"`
+	RequestCount uint
-	Yes          bool          `json:"yes"`
+	Duration     time.Duration
-	Params       types.Params  `json:"params"`
+	Yes          bool
-	Headers      types.Headers `json:"headers"`
+	Params       types.Params
-	Cookies      types.Cookies `json:"cookies"`
+	Headers      types.Headers
-	Body         types.Body    `json:"body"`
+	Cookies      types.Cookies
-	Proxies      types.Proxies `json:"proxies"`
+	Body         types.Body
+	Proxies      types.Proxies
 }
 
 func NewRequestConfig(conf *Config) *RequestConfig {
@@ -47,6 +49,7 @@ func NewRequestConfig(conf *Config) *RequestConfig {
 		Timeout:      conf.Timeout.Duration,
 		DodosCount:   *conf.DodosCount,
 		RequestCount: *conf.RequestCount,
+		Duration:     conf.Duration.Duration,
 		Yes:          *conf.Yes,
 		Params:       conf.Params,
 		Headers:      conf.Headers,
@@ -57,6 +60,9 @@ func NewRequestConfig(conf *Config) *RequestConfig {
 }
 
 func (rc *RequestConfig) GetValidDodosCountForRequests() uint {
+	if rc.RequestCount == 0 {
+		return rc.DodosCount
+	}
 	return min(rc.DodosCount, rc.RequestCount)
 }
 
@@ -95,7 +101,17 @@ func (rc *RequestConfig) Print() {
 	t.AppendSeparator()
 	t.AppendRow(table.Row{"Dodos", rc.DodosCount})
 	t.AppendSeparator()
-	t.AppendRow(table.Row{"Requests", rc.RequestCount})
+	if rc.RequestCount > 0 {
+		t.AppendRow(table.Row{"Requests", rc.RequestCount})
+	} else {
+		t.AppendRow(table.Row{"Requests"})
+	}
+	t.AppendSeparator()
+	if rc.Duration > 0 {
+		t.AppendRow(table.Row{"Duration", rc.Duration})
+	} else {
+		t.AppendRow(table.Row{"Duration"})
+	}
 	t.AppendSeparator()
 	t.AppendRow(table.Row{"Params", rc.Params.String()})
 	t.AppendSeparator()
@@ -111,60 +127,63 @@ func (rc *RequestConfig) Print() {
 }
 
 type Config struct {
-	Method       *string           `json:"method"`
+	Method       *string           `json:"method" yaml:"method"`
-	URL          *types.RequestURL `json:"url"`
+	URL          *types.RequestURL `json:"url" yaml:"url"`
-	Timeout      *types.Timeout    `json:"timeout"`
+	Timeout      *types.Timeout    `json:"timeout" yaml:"timeout"`
-	DodosCount   *uint             `json:"dodos"`
+	DodosCount   *uint             `json:"dodos" yaml:"dodos"`
-	RequestCount *uint             `json:"requests"`
+	RequestCount *uint             `json:"requests" yaml:"requests"`
-	Yes          *bool             `json:"yes"`
+	Duration     *types.Duration   `json:"duration" yaml:"duration"`
-	Params       types.Params      `json:"params"`
+	Yes          *bool             `json:"yes" yaml:"yes"`
-	Headers      types.Headers     `json:"headers"`
+	Params       types.Params      `json:"params" yaml:"params"`
-	Cookies      types.Cookies     `json:"cookies"`
+	Headers      types.Headers     `json:"headers" yaml:"headers"`
-	Body         types.Body        `json:"body"`
+	Cookies      types.Cookies     `json:"cookies" yaml:"cookies"`
-	Proxies      types.Proxies     `json:"proxy"`
+	Body         types.Body        `json:"body" yaml:"body"`
+	Proxies      types.Proxies     `json:"proxy" yaml:"proxy"`
 }
 
 func NewConfig() *Config {
 	return &Config{}
 }
 
-func (c *Config) Validate() []error {
+func (config *Config) Validate() []error {
 	var errs []error
-	if utils.IsNilOrZero(c.URL) {
+	if utils.IsNilOrZero(config.URL) {
 		errs = append(errs, errors.New("request URL is required"))
-	}
+	} else {
-	if c.URL.Scheme == "" {
+		if config.URL.Scheme == "" {
-		c.URL.Scheme = "http"
+			config.URL.Scheme = "http"
-	}
+		}
-	if c.URL.Scheme != "http" && c.URL.Scheme != "https" {
+		if config.URL.Scheme != "http" && config.URL.Scheme != "https" {
-		errs = append(errs, errors.New("request URL scheme must be http or https"))
+			errs = append(errs, errors.New("request URL scheme must be http or https"))
-	}
-	urlParams := types.Params{}
-	for key, values := range c.URL.Query() {
-		for _, value := range values {
-			urlParams = append(urlParams, types.KeyValue[string, []string]{
-				Key:   key,
-				Value: []string{value},
-			})
 		}
-	}
-	c.Params = append(urlParams, c.Params...)
-	c.URL.RawQuery = ""
 
-	if utils.IsNilOrZero(c.Method) {
+		urlParams := types.Params{}
+		for key, values := range config.URL.Query() {
+			for _, value := range values {
+				urlParams = append(urlParams, types.KeyValue[string, []string]{
+					Key:   key,
+					Value: []string{value},
+				})
+			}
+		}
+		config.Params = append(urlParams, config.Params...)
+		config.URL.RawQuery = ""
+	}
+
+	if utils.IsNilOrZero(config.Method) {
 		errs = append(errs, errors.New("request method is required"))
 	}
-	if utils.IsNilOrZero(c.Timeout) {
+	if utils.IsNilOrZero(config.Timeout) {
 		errs = append(errs, errors.New("request timeout must be greater than 0"))
 	}
-	if utils.IsNilOrZero(c.DodosCount) {
+	if utils.IsNilOrZero(config.DodosCount) {
 		errs = append(errs, errors.New("dodos count must be greater than 0"))
 	}
-	if utils.IsNilOrZero(c.RequestCount) {
+	if utils.IsNilOrZero(config.Duration) && utils.IsNilOrZero(config.RequestCount) {
-		errs = append(errs, errors.New("request count must be greater than 0"))
+		errs = append(errs, errors.New("you should provide at least one of duration or request count"))
 	}
 
-	for i, proxy := range c.Proxies {
+	for i, proxy := range config.Proxies {
 		if proxy.String() == "" {
 			errs = append(errs, fmt.Errorf("proxies[%d]: proxy cannot be empty", i))
 		} else if schema := proxy.Scheme; !slices.Contains(SupportedProxySchemes, schema) {
@@ -195,6 +214,9 @@ func (config *Config) MergeConfig(newConfig *Config) {
 	if newConfig.RequestCount != nil {
 		config.RequestCount = newConfig.RequestCount
 	}
+	if newConfig.Duration != nil {
+		config.Duration = newConfig.Duration
+	}
 	if newConfig.Yes != nil {
 		config.Yes = newConfig.Yes
 	}
@@ -228,7 +250,11 @@ func (config *Config) SetDefaults() {
 	if config.RequestCount == nil {
 		config.RequestCount = utils.ToPtr(DefaultRequestCount)
 	}
+	if config.Duration == nil {
+		config.Duration = &types.Duration{Duration: DefaultDuration}
+	}
 	if config.Yes == nil {
 		config.Yes = utils.ToPtr(DefaultYes)
 	}
+	config.Headers.SetIfNotExists("User-Agent", DefaultUserAgent)
 }

config/file.go

@@ -7,40 +7,55 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/aykhans/dodo/types"
+	"gopkg.in/yaml.v3"
 )
 
+var supportedFileTypes = []string{"json", "yaml", "yml"}
+
 func (config *Config) ReadFile(filePath types.ConfigFile) error {
 	var (
 		data []byte
 		err  error
 	)
 
-	if filePath.LocationType() == types.FileLocationTypeRemoteHTTP {
+	fileExt := filePath.Extension()
-		client := &http.Client{
+	if slices.Contains(supportedFileTypes, fileExt) {
-			Timeout: 10 * time.Second,
+		if filePath.LocationType() == types.FileLocationTypeRemoteHTTP {
+			client := &http.Client{
+				Timeout: 10 * time.Second,
+			}
+
+			resp, err := client.Get(filePath.String())
+			if err != nil {
+				return fmt.Errorf("failed to fetch config file from %s", filePath)
+			}
+			defer func() { _ = resp.Body.Close() }()
+
+			data, err = io.ReadAll(io.Reader(resp.Body))
+			if err != nil {
+				return fmt.Errorf("failed to read config file from %s", filePath)
+			}
+		} else {
+			data, err = os.ReadFile(filePath.String())
+			if err != nil {
+				return errors.New("failed to read config file from " + filePath.String())
+			}
 		}
 
-		resp, err := client.Get(filePath.String())
+		switch fileExt {
-		if err != nil {
+		case "json":
-			return fmt.Errorf("failed to fetch config file from %s", filePath)
+			return parseJSONConfig(data, config)
-		}
+		case "yml", "yaml":
-		defer resp.Body.Close()
+			return parseYAMLConfig(data, config)
-
-		data, err = io.ReadAll(io.Reader(resp.Body))
-		if err != nil {
-			return fmt.Errorf("failed to read config file from %s", filePath)
-		}
-	} else {
-		data, err = os.ReadFile(filePath.String())
-		if err != nil {
-			return errors.New("failed to read config file from " + filePath.String())
 		}
 	}
 
-	return parseJSONConfig(data, config)
+	return fmt.Errorf("unsupported config file type (supported types: %v)", strings.Join(supportedFileTypes, ", "))
 }
 
 func parseJSONConfig(data []byte, config *Config) error {
@@ -58,3 +73,12 @@ func parseJSONConfig(data []byte, config *Config) error {
 
 	return nil
 }
+
+func parseYAMLConfig(data []byte, config *Config) error {
+	err := yaml.Unmarshal(data, &config)
+	if err != nil {
+		return fmt.Errorf("YAML Config file: %s", err.Error())
+	}
+
+	return nil
+}

go.mod

@@ -1,20 +1,21 @@
 module github.com/aykhans/dodo
 
-go 1.24.0
+go 1.24.2
 
 require (
 	github.com/jedib0t/go-pretty/v6 v6.6.7
-	github.com/valyala/fasthttp v1.59.0
+	github.com/valyala/fasthttp v1.62.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/andybalholm/brotli v1.1.1 // indirect
-	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	golang.org/x/net v0.36.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/term v0.29.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 )

go.sum

@@ -4,8 +4,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/jedib0t/go-pretty/v6 v6.6.7 h1:m+LbHpm0aIAPLzLbMfn8dc3Ht8MW7lsSO4MPItz/Uuo=
 github.com/jedib0t/go-pretty/v6 v6.6.7/go.mod h1:YwC5CE4fJ1HFUDeivSV1r//AmANFHyqczZk+U6BDALU=
-github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -17,17 +17,19 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.59.0 h1:Qu0qYHfXvPk1mSLNqcFtEk6DpxgA26hy6bmydotDpRI=
+github.com/valyala/fasthttp v1.62.0 h1:8dKRBX/y2rCzyc6903Zu1+3qN0H/d2MsxPPmVNamiH0=
-github.com/valyala/fasthttp v1.59.0/go.mod h1:GTxNb9Bc6r2a9D0TWNSPwDz78UxnTGBViY3xZNEqyYU=
+github.com/valyala/fasthttp v1.62.0/go.mod h1:FCINgr4GKdKqV8Q0xv8b+UxPV+H/O5nNFo3D+r54Htg=
 github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
 github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
-golang.org/x/net v0.36.0 h1:vWF2fRbw4qslQsQzgFqZff+BItCvGFQqKzKIzx1rmoA=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
-golang.org/x/net v0.36.0/go.mod h1:bFmbeoIPfrw4sMHNhb4J9f6+tPziuGjq7Jk/38fxi1I=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

requests/client.go

@@ -2,6 +2,7 @@ package requests
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"math/rand"
 	"net/url"
@@ -39,8 +40,11 @@ func getClients(
 			}
 
 			clients = append(clients, &fasthttp.HostClient{
-				MaxConns:            int(maxConns),
+				MaxConns: int(maxConns),
-				IsTLS:               isTLS,
+				IsTLS:    isTLS,
+				TLSConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
 				Addr:                addr,
 				Dial:                dialFunc,
 				MaxIdleConnDuration: timeout,
@@ -56,6 +60,9 @@ func getClients(
 	client := &fasthttp.HostClient{
 		MaxConns:            int(maxConns),
 		IsTLS:               isTLS,
+		TLSConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
 		Addr:                URL.Host,
 		MaxIdleConnDuration: timeout,
 		MaxConnDuration:     timeout,
@@ -72,11 +79,12 @@ func getClients(
 func getDialFunc(proxy *url.URL, timeout time.Duration) (fasthttp.DialFunc, error) {
 	var dialer fasthttp.DialFunc
 
-	if proxy.Scheme == "socks5" || proxy.Scheme == "socks5h" {
+	switch proxy.Scheme {
+	case "socks5", "socks5h":
 		dialer = fasthttpproxy.FasthttpSocksDialerDualStack(proxy.String())
-	} else if proxy.Scheme == "http" {
+	case "http":
 		dialer = fasthttpproxy.FasthttpHTTPDialerDualStackTimeout(proxy.String(), timeout)
-	} else {
+	default:
 		return nil, errors.New("unsupported proxy scheme")
 	}
 	return dialer, nil

requests/helper.go

@@ -17,7 +17,7 @@ import (
 func streamProgress(
 	ctx context.Context,
 	wg *sync.WaitGroup,
-	total int64,
+	total uint,
 	message string,
 	increase <-chan int64,
 ) {
@@ -27,21 +27,26 @@ func streamProgress(
 	pw.SetStyle(progress.StyleBlocks)
 	pw.SetTrackerLength(40)
 	pw.SetUpdateFrequency(time.Millisecond * 250)
+	if total == 0 {
+		pw.Style().Visibility.Percentage = false
+	}
 	go pw.Render()
 	dodosTracker := progress.Tracker{
 		Message: message,
-		Total:   total,
+		Total:   int64(total),
 	}
 	pw.AppendTracker(&dodosTracker)
+
 	for {
 		select {
 		case <-ctx.Done():
-			if ctx.Err() != context.Canceled {
+			if err := ctx.Err(); err == context.Canceled || err == context.DeadlineExceeded {
+				dodosTracker.MarkAsDone()
+			} else {
 				dodosTracker.MarkAsErrored()
 			}
+			time.Sleep(time.Millisecond * 300)
 			fmt.Printf("\r")
-			time.Sleep(time.Millisecond * 500)
-			pw.Stop()
 			return
 
 		case value := <-increase:

requests/request.go

@@ -166,9 +166,6 @@ func setRequestHeaders(req *fasthttp.Request, headers []types.KeyValue[string, s
 	for _, header := range headers {
 		req.Header.Add(header.Key, header.Value)
 	}
-	if req.Header.UserAgent() == nil {
-		req.Header.SetUserAgent(config.DefaultUserAgent)
-	}
 }
 
 // setRequestCookies adds the cookies of the given request with the provided key-value pairs.

requests/run.go

@@ -20,6 +20,12 @@ import (
 //   - ctx: The context for managing request lifecycle and cancellation.
 //   - requestConfig: The configuration for the request, including timeout, proxies, and other settings.
 func Run(ctx context.Context, requestConfig *config.RequestConfig) (Responses, error) {
+	if requestConfig.Duration > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, requestConfig.Duration)
+		defer cancel()
+	}
+
 	clients := getClients(
 		ctx,
 		requestConfig.Timeout,
@@ -58,47 +64,60 @@ func releaseDodos(
 		wg                  sync.WaitGroup
 		streamWG            sync.WaitGroup
 		requestCountPerDodo uint
-		dodosCount          uint = requestConfig.GetValidDodosCountForRequests()
+		dodosCount          = requestConfig.GetValidDodosCountForRequests()
-		dodosCountInt       int  = int(dodosCount)
+		responses           = make([][]*Response, dodosCount)
-		responses                = make([][]*Response, dodosCount)
+		increase            = make(chan int64, requestConfig.RequestCount)
-		increase                 = make(chan int64, requestConfig.RequestCount)
 	)
 
-	wg.Add(dodosCountInt)
+	wg.Add(int(dodosCount))
 	streamWG.Add(1)
 	streamCtx, streamCtxCancel := context.WithCancel(context.Background())
 
-	go streamProgress(streamCtx, &streamWG, int64(requestConfig.RequestCount), "Dodos Working🔥", increase)
+	go streamProgress(streamCtx, &streamWG, requestConfig.RequestCount, "Dodos Working🔥", increase)
 
-	for i := range dodosCount {
+	if requestConfig.RequestCount == 0 {
-		if i+1 == dodosCount {
+		for i := range dodosCount {
-			requestCountPerDodo = requestConfig.RequestCount - (i * requestConfig.RequestCount / dodosCount)
+			go sendRequest(
-		} else {
+				ctx,
-			requestCountPerDodo = ((i + 1) * requestConfig.RequestCount / dodosCount) -
+				newRequest(*requestConfig, clients, int64(i)),
-				(i * requestConfig.RequestCount / dodosCount)
+				requestConfig.Timeout,
+				&responses[i],
+				increase,
+				&wg,
+			)
 		}
+	} else {
+		for i := range dodosCount {
+			if i+1 == dodosCount {
+				requestCountPerDodo = requestConfig.RequestCount - (i * requestConfig.RequestCount / dodosCount)
+			} else {
+				requestCountPerDodo = ((i + 1) * requestConfig.RequestCount / dodosCount) -
+					(i * requestConfig.RequestCount / dodosCount)
+			}
 
-		go sendRequest(
+			go sendRequestByCount(
-			ctx,
+				ctx,
-			newRequest(*requestConfig, clients, int64(i)),
+				newRequest(*requestConfig, clients, int64(i)),
-			requestConfig.Timeout,
+				requestConfig.Timeout,
-			requestCountPerDodo,
+				requestCountPerDodo,
-			&responses[i],
+				&responses[i],
-			increase,
+				increase,
-			&wg,
+				&wg,
-		)
+			)
+		}
 	}
+
 	wg.Wait()
 	streamCtxCancel()
 	streamWG.Wait()
 	return utils.Flatten(responses)
 }
 
-// sendRequest sends a specified number of HTTP requests concurrently with a given timeout.
+// sendRequestByCount sends a specified number of HTTP requests concurrently with a given timeout.
 // It appends the responses to the provided responseData slice and sends the count of completed requests
 // to the increase channel. The function terminates early if the context is canceled or if a custom
 // interrupt error is encountered.
-func sendRequest(
+func sendRequestByCount(
 	ctx context.Context,
 	request *Request,
 	timeout time.Duration,
@@ -142,3 +161,50 @@ func sendRequest(
 		}()
 	}
 }
+
+// sendRequest continuously sends HTTP requests until the context is canceled.
+// It records the response status code or error message along with the response time,
+// and signals each completed request through the increase channel.
+func sendRequest(
+	ctx context.Context,
+	request *Request,
+	timeout time.Duration,
+	responseData *[]*Response,
+	increase chan<- int64,
+	wg *sync.WaitGroup,
+) {
+	defer wg.Done()
+
+	for {
+		if ctx.Err() != nil {
+			return
+		}
+
+		func() {
+			startTime := time.Now()
+			response, err := request.Send(ctx, timeout)
+			completedTime := time.Since(startTime)
+			if response != nil {
+				defer fasthttp.ReleaseResponse(response)
+			}
+
+			if err != nil {
+				if err == types.ErrInterrupt {
+					return
+				}
+				*responseData = append(*responseData, &Response{
+					Response: err.Error(),
+					Time:     completedTime,
+				})
+				increase <- 1
+				return
+			}
+
+			*responseData = append(*responseData, &Response{
+				Response: strconv.Itoa(response.StatusCode()),
+				Time:     completedTime,
+			})
+			increase <- 1
+		}()
+	}
+}

types/body.go

@@ -13,12 +13,12 @@ type Body []string
 func (body Body) String() string {
 	var buffer bytes.Buffer
 	if len(body) == 0 {
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	if len(body) == 1 {
 		buffer.WriteString(body[0])
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	buffer.WriteString(text.FgBlue.Sprint("Random") + "[\n")
@@ -41,7 +41,7 @@ func (body Body) String() string {
 	}
 
 	buffer.WriteString("\n]")
-	return string(buffer.Bytes())
+	return buffer.String()
 }
 
 func (body *Body) UnmarshalJSON(b []byte) error {
@@ -66,6 +66,28 @@ func (body *Body) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (body *Body) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var data any
+	if err := unmarshal(&data); err != nil {
+		return err
+	}
+
+	switch v := data.(type) {
+	case string:
+		*body = []string{v}
+	case []any:
+		var slice []string
+		for _, item := range v {
+			slice = append(slice, fmt.Sprintf("%v", item))
+		}
+		*body = slice
+	default:
+		return fmt.Errorf("invalid type for Body: %T (should be string or []string)", v)
+	}
+
+	return nil
+}
+
 func (body *Body) Set(value string) error {
 	*body = append(*body, value)
 	return nil

types/config_file.go

@@ -11,13 +11,22 @@ const (
 
 type ConfigFile string
 
-func (config ConfigFile) String() string {
+func (configFile ConfigFile) String() string {
-	return string(config)
+	return string(configFile)
 }
 
-func (config ConfigFile) LocationType() FileLocationType {
+func (configFile ConfigFile) LocationType() FileLocationType {
-	if strings.HasPrefix(string(config), "http://") || strings.HasPrefix(string(config), "https://") {
+	if strings.HasPrefix(string(configFile), "http://") || strings.HasPrefix(string(configFile), "https://") {
 		return FileLocationTypeRemoteHTTP
 	}
 	return FileLocationTypeLocal
 }
+
+func (configFile ConfigFile) Extension() string {
+	i := strings.LastIndex(configFile.String(), ".")
+	if i == -1 {
+		return ""
+	}
+
+	return configFile.String()[i+1:]
+}

types/cookies.go

@@ -14,7 +14,7 @@ type Cookies []KeyValue[string, []string]
 func (cookies Cookies) String() string {
 	var buffer bytes.Buffer
 	if len(cookies) == 0 {
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	indent := "  "
@@ -53,7 +53,24 @@ func (cookies Cookies) String() string {
 		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d cookies", remainingPairs))
 	}
 
-	return string(buffer.Bytes())
+	return buffer.String()
+}
+
+func (cookies *Cookies) AppendByKey(key, value string) {
+	if item := cookies.GetValue(key); item != nil {
+		*item = append(*item, value)
+	} else {
+		*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (cookies Cookies) GetValue(key string) *[]string {
+	for i := range cookies {
+		if cookies[i].Key == key {
+			return &cookies[i].Value
+		}
+	}
+	return nil
 }
 
 func (cookies *Cookies) UnmarshalJSON(b []byte) error {
@@ -82,6 +99,31 @@ func (cookies *Cookies) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (cookies *Cookies) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var raw []map[string]any
+	if err := unmarshal(&raw); err != nil {
+		return err
+	}
+
+	for _, param := range raw {
+		for key, value := range param {
+			switch parsed := value.(type) {
+			case string:
+				*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: []string{parsed}})
+			case []any:
+				var values []string
+				for _, v := range parsed {
+					if str, ok := v.(string); ok {
+						values = append(values, str)
+					}
+				}
+				*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: values})
+			}
+		}
+	}
+	return nil
+}
+
 func (cookies *Cookies) Set(value string) error {
 	parts := strings.SplitN(value, "=", 2)
 	switch len(parts) {
@@ -95,20 +137,3 @@ func (cookies *Cookies) Set(value string) error {
 
 	return nil
 }
-
-func (cookies *Cookies) AppendByKey(key, value string) {
-	if item := cookies.GetValue(key); item != nil {
-		*item = append(*item, value)
-	} else {
-		*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: []string{value}})
-	}
-}
-
-func (cookies Cookies) GetValue(key string) *[]string {
-	for i := range cookies {
-		if cookies[i].Key == key {
-			return &cookies[i].Value
-		}
-	}
-	return nil
-}

types/duration.go

@@ -6,31 +6,52 @@ import (
 	"time"
 )
 
-type Timeout struct {
+type Duration struct {
 	time.Duration
 }
 
-func (timeout *Timeout) UnmarshalJSON(b []byte) error {
+func (duration *Duration) UnmarshalJSON(b []byte) error {
 	var v any
 	if err := json.Unmarshal(b, &v); err != nil {
 		return err
 	}
 	switch value := v.(type) {
 	case float64:
-		timeout.Duration = time.Duration(value)
+		duration.Duration = time.Duration(value)
 		return nil
 	case string:
 		var err error
-		timeout.Duration, err = time.ParseDuration(value)
+		duration.Duration, err = time.ParseDuration(value)
 		if err != nil {
-			return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+			return errors.New("Duration is invalid (e.g. 400ms, 1s, 5m, 1h)")
 		}
 		return nil
 	default:
-		return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+		return errors.New("Duration is invalid (e.g. 400ms, 1s, 5m, 1h)")
 	}
 }
 
-func (timeout Timeout) MarshalJSON() ([]byte, error) {
+func (duration Duration) MarshalJSON() ([]byte, error) {
-	return json.Marshal(timeout.Duration.String())
+	return json.Marshal(duration.String())
+}
+
+func (duration *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var v any
+	if err := unmarshal(&v); err != nil {
+		return err
+	}
+	switch value := v.(type) {
+	case float64:
+		duration.Duration = time.Duration(value)
+		return nil
+	case string:
+		var err error
+		duration.Duration, err = time.ParseDuration(value)
+		if err != nil {
+			return errors.New("Duration is invalid (e.g. 400ms, 1s, 5m, 1h)")
+		}
+		return nil
+	default:
+		return errors.New("Duration is invalid (e.g. 400ms, 1s, 5m, 1h)")
+	}
 }

types/headers.go

@@ -14,7 +14,7 @@ type Headers []KeyValue[string, []string]
 func (headers Headers) String() string {
 	var buffer bytes.Buffer
 	if len(headers) == 0 {
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	indent := "  "
@@ -53,7 +53,33 @@ func (headers Headers) String() string {
 		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d headers", remainingPairs))
 	}
 
-	return string(buffer.Bytes())
+	return buffer.String()
+}
+
+func (headers *Headers) AppendByKey(key, value string) {
+	if item := headers.GetValue(key); item != nil {
+		*item = append(*item, value)
+	} else {
+		*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (headers Headers) GetValue(key string) *[]string {
+	for i := range headers {
+		if headers[i].Key == key {
+			return &headers[i].Value
+		}
+	}
+	return nil
+}
+
+func (headers Headers) Has(key string) bool {
+	for i := range headers {
+		if headers[i].Key == key {
+			return true
+		}
+	}
+	return false
 }
 
 func (headers *Headers) UnmarshalJSON(b []byte) error {
@@ -82,6 +108,31 @@ func (headers *Headers) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (headers *Headers) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var raw []map[string]any
+	if err := unmarshal(&raw); err != nil {
+		return err
+	}
+
+	for _, param := range raw {
+		for key, value := range param {
+			switch parsed := value.(type) {
+			case string:
+				*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{parsed}})
+			case []any:
+				var values []string
+				for _, v := range parsed {
+					if str, ok := v.(string); ok {
+						values = append(values, str)
+					}
+				}
+				*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: values})
+			}
+		}
+	}
+	return nil
+}
+
 func (headers *Headers) Set(value string) error {
 	parts := strings.SplitN(value, ":", 2)
 	switch len(parts) {
@@ -96,19 +147,10 @@ func (headers *Headers) Set(value string) error {
 	return nil
 }
 
-func (headers *Headers) AppendByKey(key, value string) {
+func (headers *Headers) SetIfNotExists(key string, value string) bool {
-	if item := headers.GetValue(key); item != nil {
+	if headers.Has(key) {
-		*item = append(*item, value)
+		return false
-	} else {
-		*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{value}})
 	}
-}
+	*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{value}})
-
+	return true
-func (headers Headers) GetValue(key string) *[]string {
-	for i := range headers {
-		if headers[i].Key == key {
-			return &headers[i].Value
-		}
-	}
-	return nil
 }

types/params.go

@@ -14,7 +14,7 @@ type Params []KeyValue[string, []string]
 func (params Params) String() string {
 	var buffer bytes.Buffer
 	if len(params) == 0 {
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	indent := "  "
@@ -53,7 +53,24 @@ func (params Params) String() string {
 		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d params", remainingPairs))
 	}
 
-	return string(buffer.Bytes())
+	return buffer.String()
+}
+
+func (params *Params) AppendByKey(key, value string) {
+	if item := params.GetValue(key); item != nil {
+		*item = append(*item, value)
+	} else {
+		*params = append(*params, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (params Params) GetValue(key string) *[]string {
+	for i := range params {
+		if params[i].Key == key {
+			return &params[i].Value
+		}
+	}
+	return nil
 }
 
 func (params *Params) UnmarshalJSON(b []byte) error {
@@ -82,6 +99,31 @@ func (params *Params) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (params *Params) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var raw []map[string]any
+	if err := unmarshal(&raw); err != nil {
+		return err
+	}
+
+	for _, param := range raw {
+		for key, value := range param {
+			switch parsed := value.(type) {
+			case string:
+				*params = append(*params, KeyValue[string, []string]{Key: key, Value: []string{parsed}})
+			case []any:
+				var values []string
+				for _, v := range parsed {
+					if str, ok := v.(string); ok {
+						values = append(values, str)
+					}
+				}
+				*params = append(*params, KeyValue[string, []string]{Key: key, Value: values})
+			}
+		}
+	}
+	return nil
+}
+
 func (params *Params) Set(value string) error {
 	parts := strings.SplitN(value, "=", 2)
 	switch len(parts) {
@@ -95,20 +137,3 @@ func (params *Params) Set(value string) error {
 
 	return nil
 }
-
-func (params *Params) AppendByKey(key, value string) {
-	if item := params.GetValue(key); item != nil {
-		*item = append(*item, value)
-	} else {
-		*params = append(*params, KeyValue[string, []string]{Key: key, Value: []string{value}})
-	}
-}
-
-func (params Params) GetValue(key string) *[]string {
-	for i := range params {
-		if params[i].Key == key {
-			return &params[i].Value
-		}
-	}
-	return nil
-}

types/proxies.go

@@ -14,12 +14,12 @@ type Proxies []url.URL
 func (proxies Proxies) String() string {
 	var buffer bytes.Buffer
 	if len(proxies) == 0 {
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	if len(proxies) == 1 {
 		buffer.WriteString(proxies[0].String())
-		return string(buffer.Bytes())
+		return buffer.String()
 	}
 
 	buffer.WriteString(text.FgBlue.Sprint("Random") + "[\n")
@@ -42,7 +42,7 @@ func (proxies Proxies) String() string {
 	}
 
 	buffer.WriteString("\n]")
-	return string(buffer.Bytes())
+	return buffer.String()
 }
 
 func (proxies *Proxies) UnmarshalJSON(b []byte) error {
@@ -75,6 +75,36 @@ func (proxies *Proxies) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (proxies *Proxies) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var data any
+	if err := unmarshal(&data); err != nil {
+		return err
+	}
+
+	switch v := data.(type) {
+	case string:
+		parsed, err := url.Parse(v)
+		if err != nil {
+			return err
+		}
+		*proxies = []url.URL{*parsed}
+	case []any:
+		var urls []url.URL
+		for _, item := range v {
+			url, err := url.Parse(item.(string))
+			if err != nil {
+				return err
+			}
+			urls = append(urls, *url)
+		}
+		*proxies = urls
+	default:
+		return fmt.Errorf("invalid type for Body: %T (should be URL or []URL)", v)
+	}
+
+	return nil
+}
+
 func (proxies *Proxies) Set(value string) error {
 	parsedURL, err := url.Parse(value)
 	if err != nil {

types/request_url.go

@@ -18,7 +18,22 @@ func (requestURL *RequestURL) UnmarshalJSON(data []byte) error {
 
 	parsedURL, err := url.Parse(urlStr)
 	if err != nil {
-		return errors.New("Request URL is invalid")
+		return errors.New("request URL is invalid")
+	}
+
+	requestURL.URL = *parsedURL
+	return nil
+}
+
+func (requestURL *RequestURL) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var urlStr string
+	if err := unmarshal(&urlStr); err != nil {
+		return err
+	}
+
+	parsedURL, err := url.Parse(urlStr)
+	if err != nil {
+		return errors.New("request URL is invalid")
 	}
 
 	requestURL.URL = *parsedURL

types/timeout.go

@@ -0,0 +1,57 @@
+package types
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+type Timeout struct {
+	time.Duration
+}
+
+func (timeout *Timeout) UnmarshalJSON(b []byte) error {
+	var v any
+	if err := json.Unmarshal(b, &v); err != nil {
+		return err
+	}
+	switch value := v.(type) {
+	case float64:
+		timeout.Duration = time.Duration(value)
+		return nil
+	case string:
+		var err error
+		timeout.Duration, err = time.ParseDuration(value)
+		if err != nil {
+			return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+		}
+		return nil
+	default:
+		return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+	}
+}
+
+func (timeout Timeout) MarshalJSON() ([]byte, error) {
+	return json.Marshal(timeout.String())
+}
+
+func (timeout *Timeout) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var v any
+	if err := unmarshal(&v); err != nil {
+		return err
+	}
+	switch value := v.(type) {
+	case float64:
+		timeout.Duration = time.Duration(value)
+		return nil
+	case string:
+		var err error
+		timeout.Duration, err = time.ParseDuration(value)
+		if err != nil {
+			return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+		}
+		return nil
+	default:
+		return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+	}
+}

utils/compare.go

@@ -6,9 +6,5 @@ func IsNilOrZero[T comparable](value *T) bool {
 	}
 
 	var zero T
-	if *value == zero {
+	return *value == zero
-		return true
-	}
-
-	return false
 }

utils/slice.go

@@ -20,9 +20,9 @@ func Flatten[T any](nested [][]*T) []*T {
 // The returned function isn't thread-safe and should be used in a single-threaded context.
 func RandomValueCycle[Value any](values []Value, localRand *rand.Rand) func() Value {
 	var (
-		clientsCount int = len(values)
+		clientsCount = len(values)
-		currentIndex int = localRand.Intn(clientsCount)
+		currentIndex = localRand.Intn(clientsCount)
-		stopIndex    int = currentIndex
+		stopIndex    = currentIndex
 	)
 
 	return func() Value {