update handle queue binding

auth/encrryption.go

@@ -0,0 +1,84 @@
+package auth
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"io"
+
+	"github.com/ochom/gutils/env"
+)
+
+// Vault
+type Vault struct {
+	key string
+}
+
+// NewVault creates a new Vault with the given key
+func NewVault(keys ...string) (*Vault, error) {
+	key := env.Get("VAULT_KEY")
+
+	if len(keys) > 0 && keys[0] != "" {
+		key = keys[0]
+	}
+
+	if len(key) != 32 {
+		return nil, fmt.Errorf("vault key must be 32 bytes long")
+	}
+
+	return &Vault{key: key}, nil
+}
+
+// Encrypt text using AES-GCM
+func (v Vault) Encrypt(plaintext string) (string, error) {
+	block, err := aes.NewCipher([]byte(v.key))
+	if err != nil {
+		return "", err
+	}
+
+	aesGCM, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonce := make([]byte, aesGCM.NonceSize())
+	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", err
+	}
+
+	ciphertext := aesGCM.Seal(nonce, nonce, []byte(plaintext), nil)
+	return base64.StdEncoding.EncodeToString(ciphertext), nil
+}
+
+// Decrypt text using AES-GCM
+func (v Vault) Decrypt(encryptedText string) (string, error) {
+	data, err := base64.StdEncoding.DecodeString(encryptedText)
+	if err != nil {
+		return "", err
+	}
+
+	block, err := aes.NewCipher([]byte(v.key))
+	if err != nil {
+		return "", err
+	}
+
+	aesGCM, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonceSize := aesGCM.NonceSize()
+	if len(data) < nonceSize {
+		return "", fmt.Errorf("ciphertext too short")
+	}
+
+	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
+	plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return string(plaintext), nil
+}

auth/encrryption_test.go

@@ -0,0 +1,38 @@
+package auth_test
+
+import (
+	"testing"
+
+	"github.com/ochom/gutils/auth"
+)
+
+func TestVault_Encrypt(t *testing.T) {
+	vault, err := auth.NewVault("12345678901234567890123456789012")
+	if err != nil {
+		t.Fatalf("failed to create vault: %v", err)
+	}
+
+	plaintext := "Hello, World!"
+	encryptedText, err := vault.Encrypt(plaintext)
+	if err != nil {
+		t.Fatalf("encryption failed: %v", err)
+	}
+
+	if encryptedText == plaintext {
+		t.Fatalf("encrypted text should not be the same as plaintext")
+	}
+
+	vault2, err := auth.NewVault("12345678901234567890123456789012")
+	if err != nil {
+		t.Fatalf("failed to create vault: %v", err)
+	}
+
+	decryptedText, err := vault2.Decrypt(encryptedText)
+	if err != nil {
+		t.Fatalf("decryption failed: %v", err)
+	}
+
+	if decryptedText != plaintext {
+		t.Fatalf("decrypted text does not match original plaintext")
+	}
+}

env/env_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestGetEnv(t *testing.T) {
-	os.Setenv("HELLO", "world")
+	_ = os.Setenv("HELLO", "world")
 	type args struct {
 		key          string
 		defaultValue string
@@ -45,8 +45,8 @@ func TestGetEnv(t *testing.T) {
 }
 
 func TestInt(t *testing.T) {
-	os.Setenv("HELLO", "45")
-	os.Setenv("HELLO2", "45s")
+	_ = os.Setenv("HELLO", "45")
+	_ = os.Setenv("HELLO2", "45s")
 
 	type args struct {
 		key          string
@@ -92,9 +92,9 @@ func TestInt(t *testing.T) {
 }
 
 func TestBool(t *testing.T) {
-	os.Setenv("HELLO", "true")
-	os.Setenv("HELLO2", "false")
-	os.Setenv("HELLO3", "test")
+	_ = os.Setenv("HELLO", "true")
+	_ = os.Setenv("HELLO2", "false")
+	_ = os.Setenv("HELLO3", "test")
 
 	type args struct {
 		key          string
@@ -148,8 +148,8 @@ func TestBool(t *testing.T) {
 }
 
 func TestFloat(t *testing.T) {
-	os.Setenv("HELLO", "45.5")
-	os.Setenv("HELLO2", "45.5s")
+	_ = os.Setenv("HELLO", "45.5")
+	_ = os.Setenv("HELLO2", "45.5s")
 
 	type args struct {
 		key          string

gttp/gofiber.go

@@ -1,7 +1,6 @@
 package gttp
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"strings"
@@ -23,71 +22,60 @@ func (c *fiberClient) get(url string, headers M, timeouts ...time.Duration) (res
 }
 
 // sendRequest sends a request to the specified URL.
-func (c *fiberClient) sendRequest(url, method string, headers M, body []byte, timeouts ...time.Duration) (resp *Response, err error) {
+func (c *fiberClient) sendRequest(url, method string, headers M, body []byte, timeouts ...time.Duration) (*Response, error) {
 	timeout := time.Hour
 	if len(timeouts) > 0 {
 		timeout = timeouts[0]
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	result := make(chan *Response, 1)
-	go func() {
-		resp := c.makeRequest(url, method, headers, body)
-		result <- resp
-	}()
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case r := <-result:
-		if len(r.Errors) == 0 {
-			return r, nil
-		}
-
-		errStrings := []string{}
-		for _, err := range r.Errors {
-			errStrings = append(errStrings, err.Error())
-		}
+	resp := c.makeRequest(url, method, headers, body, timeout)
+	if len(resp.Errors) == 0 {
+		return resp, nil
+	}
 
-		return r, errors.New(strings.Join(errStrings, ", "))
+	errStrings := []string{}
+	for _, err := range resp.Errors {
+		errStrings = append(errStrings, err.Error())
 	}
+
+	return resp, errors.New(strings.Join(errStrings, ", "))
 }
 
 // makeRequest sends a request to the specified URL.
-func (c *fiberClient) makeRequest(url, method string, headers M, body []byte) (resp *Response) {
-	client := fiber.AcquireClient()
-	var req *fiber.Agent
-
+func (c *fiberClient) makeRequest(url, method string, headers M, body []byte, timeout time.Duration) *Response {
+	var agent *fiber.Agent
 	switch method {
 	case "POST":
-		req = client.Post(url)
+		agent = fiber.Post(url)
 	case "GET":
-		req = client.Get(url)
+		agent = fiber.Get(url)
 	case "DELETE":
-		req = client.Delete(url)
+		agent = fiber.Delete(url)
 	case "PUT":
-		req = client.Put(url)
+		agent = fiber.Put(url)
 	case "PATCH":
-		req = client.Patch(url)
+		agent = fiber.Patch(url)
 	default:
 		err := fmt.Errorf("unknown method: %s", method)
 		return NewResponse(500, []error{err}, nil)
 	}
 
 	// skip ssl verification
-	req.InsecureSkipVerify()
+	agent.InsecureSkipVerify()
+	agent.Timeout(timeout)
 
+	// add request headers
 	for k, v := range headers {
-		req.Add(k, v)
+		agent.Add(k, v)
 	}
 
+	// add request body
 	if method == "POST" || method == "PUT" || method == "PATCH" {
-		req.Body(body)
+		agent.Body(body)
 	}
 
-	code, content, errs := req.Bytes()
+	// make request
+	code, content, errs := agent.Bytes()
 	if code == 0 {
 		code = 500
 	}

helpers/address.go

@@ -0,0 +1,20 @@
+package helpers
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/ochom/gutils/logs"
+)
+
+// GetAvailableAddress returns the next available address e.g :8080
+func GetAvailableAddress(port int) string {
+	_, err := net.DialTimeout("tcp", net.JoinHostPort("", fmt.Sprintf("%d", port)), time.Second)
+	if err == nil {
+		logs.Warn("[🥵] address :%d is not available trying another port...", port)
+		return GetAvailableAddress(port + 1)
+	}
+
+	return fmt.Sprintf(":%d", port)
+}

helpers/address_test.go

@@ -0,0 +1,27 @@
+package helpers
+
+import "testing"
+
+func TestGetAvailableAddress(t *testing.T) {
+	type args struct {
+		port int
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "Test GetAvailableAddress",
+			args: args{port: 8080},
+			want: ":8080",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GetAvailableAddress(tt.args.port); got != tt.want {
+				t.Errorf("GetAvailableAddress() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}