feat(ssh,api): load internal http configuration from envs

Author: henrybarreto

.env

@@ -166,3 +166,18 @@ SHELLHUB_API_BURST_DELAY=nodelay
 
 # Defines if the metrics endpoint is enabled.
 SHELLHUB_METRICS=false
+
+# Defines the number of retry attempts for the internal HTTP client when a request fails.
+SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT=3
+
+# Sets the initial wait time (in seconds) before retrying a failed request.
+SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME=5
+
+# Specifies the maximum wait time (in seconds) between retries.
+SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME=20
+
+# The base URL for the API service.
+SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL=http://api:8080
+
+# The base URL for the Enterprise service.
+SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL=http://cloud:8080

api/server.go

@@ -84,7 +84,7 @@ func (s *Server) Setup(ctx context.Context) error {
 
 	log.Debug("MongoDB store connected successfully")
 
-	apiClient, err := internalclient.NewClient(internalclient.WithAsynqWorker(s.env.RedisURI))
+	apiClient, err := internalclient.NewClient(nil, internalclient.WithAsynqWorker(s.env.RedisURI))
 	if err != nil {
 		return err
 	}

docker-compose.yml

@@ -11,6 +11,11 @@ services:
       - ALLOW_PUBLIC_KEY_ACCESS_BELLOW_0_6_0=${SHELLHUB_ALLOW_PUBLIC_KEY_ACCESS_BELLOW_0_6_0}
       - SHELLHUB_WEB_ENDPOINTS=${SHELLHUB_WEB_ENDPOINTS}
       - SHELLHUB_WEB_ENDPOINTS_DOMAIN=${SHELLHUB_WEB_ENDPOINTS_DOMAIN}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL=${SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL=${SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL}
     ports:
       - "${SHELLHUB_SSH_PORT}:2222"
     secrets:
@@ -49,6 +54,11 @@ services:
       - REDIS_CACHE_POOL_SIZE=${SHELLHUB_REDIS_CACHE_POOL_SIZE}
       - MAXIMUM_ACCOUNT_LOCKOUT=${SHELLHUB_MAXIMUM_ACCOUNT_LOCKOUT}
       - METRICS=${SHELLHUB_METRICS}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME=${SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL=${SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL}
+      - SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL=${SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL}
     depends_on:
       - mongo
       - redis

pkg/api/internalclient/client.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"net"
 	"net/http"
+	"time"
 
 	resty "github.com/go-resty/resty/v2"
 	"github.com/shellhub-io/shellhub/pkg/worker"
@@ -39,10 +40,14 @@ var (
 	ErrUnknown          = errors.New("unknown error")
 )
 
-func NewClient(opts ...clientOption) (Client, error) {
-	cfg, err := DefaultConfig()
-	if err != nil {
-		return nil, err
+func NewClient(cfg *Config, opts ...clientOption) (Client, error) {
+	if cfg == nil {
+		var err error
+
+		cfg, err = NewConfigFromEnv()
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	httpClient := resty.New()
@@ -65,8 +70,8 @@ func NewClient(opts ...clientOption) (Client, error) {
 	// NOTE: Avoid setting a global base URL on the Resty client. Calls to enterprise endpoints
 	// will use c.config.EnterpriseBaseURL explicitly when needed.
 	httpClient.SetRetryCount(c.config.RetryCount)
-	httpClient.SetRetryWaitTime(c.config.RetryWaitTime)
-	httpClient.SetRetryMaxWaitTime(c.config.RetryMaxWaitTime)
+	httpClient.SetRetryWaitTime(time.Duration(c.config.RetryWaitTime) * time.Second)
+	httpClient.SetRetryMaxWaitTime(time.Duration(c.config.RetryMaxWaitTime) * time.Second)
 	httpClient.AddRetryCondition(func(r *resty.Response, err error) bool {
 		if _, ok := err.(net.Error); ok { // if the error is a network error, retry.
 			return true
@@ -104,7 +109,6 @@ func NewClient(opts ...clientOption) (Client, error) {
 	return c, nil
 }
 
-// mustWorker panics if [client.worker] is nil.
 func (c *client) mustWorker() {
 	if c.worker == nil {
 		panic("Client does not have any worker")

pkg/api/internalclient/config.go

@@ -1,29 +1,40 @@
 package internalclient
 
-import "time"
+import (
+	"github.com/shellhub-io/shellhub/pkg/envs"
+)
 
 // Config holds configuration options for the client.
 type Config struct {
 	// RetryCount defines how many times the client should retry a request in case of failure.
-	RetryCount int
+	RetryCount int `env:"SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_COUNT,default=3"`
 	// RetryWaitTime defines the wait time between retries.
-	RetryWaitTime time.Duration
+	RetryWaitTime int `env:"SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_WAIT_TIME,default=5"`
 	// RetryMaxWaitTime defines the maximum wait time between retries.
-	RetryMaxWaitTime time.Duration
+	RetryMaxWaitTime int `env:"SHELLHUB_INTERNAL_HTTP_CLIENT_RETRY_MAX_WAIT_TIME,default=20"`
 
 	// APIBaseURL defines the base URL for the API service.
-	APIBaseURL string
+	APIBaseURL string `env:"SHELLHUB_INTERNAL_HTTP_CLIENT_API_BASE_URL,default=http://api:8080"`
 
 	// EnterpriseBaseURL defines the base URL for enterprise endpoints (cloud component).
-	EnterpriseBaseURL string
+	EnterpriseBaseURL string `env:"SHELLHUB_INTERNAL_HTTP_CLIENT_ENTERPRISE_BASE_URL,default=http://cloud:8080"`
+}
+
+func NewConfigFromEnv() (*Config, error) {
+	env, err := envs.Parse[Config]()
+	if err != nil {
+		return nil, err
+	}
+
+	return env, nil
 }
 
 // DefaultConfig returns a Config struct with default values.
 func DefaultConfig() (*Config, error) {
 	return &Config{
 		RetryCount:        3,
-		RetryWaitTime:     5 * time.Second,
-		RetryMaxWaitTime:  20 * time.Second,
+		RetryWaitTime:     5,
+		RetryMaxWaitTime:  20,
 		APIBaseURL:        "http://api:8080",
 		EnterpriseBaseURL: "http://cloud:8080",
 	}, nil

ssh/main.go

@@ -54,7 +54,7 @@ func main() {
 	})
 	if err != nil {
 		log.WithError(err).
-			Fatal("failed to create the internalclient")
+			Fatal("failed to create the tunnel")
 	}
 
 	router := tun.GetRouter()

ssh/pkg/tunnel/tunnel.go

@@ -70,7 +70,7 @@ func NewTunnel(connection string, dial string, config Config) (*Tunnel, error) {
 		return nil, err
 	}
 
-	api, err := internalclient.NewClient(internalclient.WithAsynqWorker(config.RedisURI))
+	api, err := internalclient.NewClient(nil, internalclient.WithAsynqWorker(config.RedisURI))
 	if err != nil {
 		return nil, err
 	}

ssh/session/session.go

@@ -239,7 +239,7 @@ func (s *Seats) SetPty(seat int, status bool) {
 func NewSession(ctx gliderssh.Context, tunnel *httptunnel.Tunnel, cache cache.Cache) (*Session, error) {
 	snap := getSnapshot(ctx)
 
-	api, err := internalclient.NewClient()
+	api, err := internalclient.NewClient(nil)
 	if err != nil {
 		return nil, err
 	}

ssh/web/session.go

@@ -37,7 +37,7 @@ func getAuth(ctx context.Context, conn *Conn, creds *Credentials) ([]ssh.AuthMet
 		return []ssh.AuthMethod{ssh.Password(creds.Password)}, nil
 	}
 
-	cli, err := internalclient.NewClient()
+	cli, err := internalclient.NewClient(nil)
 	if err != nil {
 		return nil, err
 	}