Support for TrueNAS' WebSocket APIs

Author: lucasdillmann

frontend/src/core/i18n/I18nService.ts

@@ -36,19 +36,19 @@ export default class I18nService {
         if (!languageTag) this.repository.clear()
         else this.repository.set(languageTag)
 
+        await this.loadDictionary(languageTag)
+
         I18nContext.replace({
             ...I18nContext.get(),
             currentLanguage: languageTag,
         })
-
-        await this.loadDictionary(languageTag)
     }
 
     private async loadDictionary(targetLanguage: string | null) {
         const context = I18nContext.get()
         const resolvedLanguage = resolveLanguageTag(
             context.availableLanguages,
-            targetLanguage ?? context.currentLanguage,
+            targetLanguage,
             context.defaultLanguage,
         )
 

integration/truenas/client/cache.go

@@ -11,14 +11,16 @@ import (
 
 var (
 	cacheDelegate *cache.Cache
-	cacheInitLock = &sync.Once{}
-	cacheMainLock = &sync.Mutex{}
+	cacheInitOnce = &sync.Once{}
+	cacheInitLock = &sync.Mutex{}
 )
 
 func initCache(cfg *configuration.Configuration) error {
-	var err error
+	cacheInitLock.Lock()
+	defer cacheInitLock.Unlock()
 
-	cacheInitLock.Do(func() {
+	var err error
+	cacheInitOnce.Do(func() {
 		cacheDuration, innerErr := cfg.GetInt(
 			"nginx-ignition.integration.truenas.api-cache-timeout-seconds",
 		)
@@ -34,22 +36,22 @@ func initCache(cfg *configuration.Configuration) error {
 	})
 
 	if err != nil {
-		cacheInitLock = &sync.Once{}
+		cacheInitOnce = &sync.Once{}
 	}
 
 	return err
 }
 
-func getFromCache[T any](key string, missProvider func() T) T {
-	cacheMainLock.Lock()
-	defer cacheMainLock.Unlock()
-
+func getFromCache[T any](key string, missProvider func() (*T, error)) (*T, error) {
 	if value, found := cacheDelegate.Get(key); found {
-		return value.(T)
+		return value.(*T), nil
 	}
 
-	value := missProvider()
-	cacheDelegate.Set(key, value, cache.DefaultExpiration)
+	value, err := missProvider()
+	if err != nil {
+		return nil, err
+	}
 
-	return value
+	cacheDelegate.Set(key, value, cache.DefaultExpiration)
+	return value, nil
 }

integration/truenas/client/client.go

@@ -28,7 +28,7 @@ func For(cfg *configuration.Configuration, parameters map[string]any) (Client, e
 func useLegacyAPI(parameters map[string]any) bool {
 	rawValue, found := parameters[fields.LegacyAPIFieldID]
 	if !found {
-		return false
+		return true
 	}
 
 	parsedValue, parsed := rawValue.(bool)

integration/truenas/client/rest_client.go

@@ -35,23 +35,26 @@ func (c *restClient) GetAvailableApps() ([]AvailableAppDTO, error) {
 
 func (c *restClient) get(endpoint string, result any) error {
 	cacheKey := fmt.Sprintf("%s:%s:rest:%s", c.baseURL, c.username, endpoint)
-	response := getFromCache(cacheKey, func() []byte {
-		output, err := c.executeGetRequest(endpoint, result)
+	response, err := getFromCache(cacheKey, func() (*[]byte, error) {
+		res, err := c.executeGetRequest(endpoint)
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 
-		return output
+		return &res, nil
 	})
+	if err != nil {
+		return err
+	}
 
 	if response != nil {
-		return json.Unmarshal(response, result)
+		return json.Unmarshal(*response, result)
 	}
 
 	return nil
 }
 
-func (c *restClient) executeGetRequest(endpoint string, result any) ([]byte, error) {
+func (c *restClient) executeGetRequest(endpoint string) ([]byte, error) {
 	req, err := http.NewRequest("GET", c.baseURL+"/api/v2.0/"+endpoint, nil)
 	if err != nil {
 		return nil, err
@@ -72,14 +75,5 @@ func (c *restClient) executeGetRequest(endpoint string, result any) ([]byte, err
 		return nil, fmt.Errorf("unexpected HTTP status %d from TrueNAS REST API", resp.StatusCode)
 	}
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	if err = json.Unmarshal(body, result); err != nil {
-		return nil, err
-	}
-
-	return body, nil
+	return io.ReadAll(resp.Body)
 }

integration/truenas/client/websocket_client.go

@@ -66,30 +66,21 @@ func newWebSocketClient(baseURL, username, password string) *webSocketClient {
 }
 
 func (c *webSocketClient) GetAvailableApps() ([]AvailableAppDTO, error) {
-	var apps []AvailableAppDTO
-
 	cacheKey := fmt.Sprintf("%s:%s:ws:app.query", c.baseURL, c.username)
-	rawBytes := getFromCache(cacheKey, func() []byte {
-		result, err := c.fetchApps()
-		if err != nil {
-			panic(err)
-		}
-
-		b, err := json.Marshal(result)
+	res, err := getFromCache(cacheKey, func() (*[]AvailableAppDTO, error) {
+		res, err := c.fetchApps()
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 
-		return b
+		return &res, nil
 	})
 
-	if rawBytes != nil {
-		if err := json.Unmarshal(rawBytes, &apps); err != nil {
-			return nil, err
-		}
+	if err != nil || res == nil {
+		return nil, err
 	}
 
-	return apps, nil
+	return *res, nil
 }
 
 func (c *webSocketClient) fetchApps() ([]AvailableAppDTO, error) {
@@ -106,8 +97,13 @@ func (c *webSocketClient) fetchApps() ([]AvailableAppDTO, error) {
 	//nolint:errcheck
 	defer conn.Close()
 
-	if err = conn.SetReadDeadline(time.Now().Add(wsTimeout)); err != nil {
-		return nil, fmt.Errorf("truenas websocket: set deadline: %w", err)
+	deadline := time.Now().Add(wsTimeout)
+	if err = conn.SetReadDeadline(deadline); err != nil {
+		return nil, fmt.Errorf("truenas websocket: set read deadline: %w", err)
+	}
+
+	if err = conn.SetWriteDeadline(deadline); err != nil {
+		return nil, fmt.Errorf("truenas websocket: set write deadline: %w", err)
 	}
 
 	if err = conn.WriteMessage(websocket.TextMessage, []byte(ddpConnectMsg)); err != nil {
@@ -190,7 +186,10 @@ func convertWSApps(raw []wsAppDTO) []AvailableAppDTO {
 }
 
 func (c *webSocketClient) waitForMsg(conn *websocket.Conn, msgType string) error {
-	for {
+	remainingAttempts := 100
+	for remainingAttempts > 0 {
+		remainingAttempts--
+
 		_, raw, err := conn.ReadMessage()
 		if err != nil {
 			return err
@@ -205,10 +204,15 @@ func (c *webSocketClient) waitForMsg(conn *websocket.Conn, msgType string) error
 			return nil
 		}
 	}
+
+	return errors.New("truenas websocket: timeout")
 }
 
 func (c *webSocketClient) waitForResult(conn *websocket.Conn, id string) (json.RawMessage, error) {
-	for {
+	remainingAttempts := 100
+	for remainingAttempts > 0 {
+		remainingAttempts--
+
 		_, raw, err := conn.ReadMessage()
 		if err != nil {
 			return nil, err
@@ -227,6 +231,8 @@ func (c *webSocketClient) waitForResult(conn *websocket.Conn, id string) (json.R
 			return msg.Result, nil
 		}
 	}
+
+	return nil, errors.New("truenas websocket: timeout")
 }
 
 func buildWSURL(baseURL string) (string, error) {

integration/truenas/driver.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net/url"
+	"strconv"
 	"strings"
 
 	"dillmann.com.br/nginx-ignition/core/common/configuration"
@@ -158,7 +159,7 @@ func (a *Driver) getWorkloadPort(
 	for _, app := range apps {
 		if app.ID == appID {
 			for _, port := range app.ActiveWorkloads.UsedPorts {
-				if fmt.Sprintf("%d", port.ContainerPort) == containerPort {
+				if strconv.Itoa(port.ContainerPort) == containerPort {
 					return &app, &port, nil
 				}
 			}