new json_data model

fix upload artifacts

.github/workflows/build.yml

@@ -0,0 +1,48 @@
+name: Build Go Binaries
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        goos: [linux, windows]
+        goarch: [amd64, arm, arm64]
+        exclude:
+          - goos: windows
+            goarch: arm
+          - goos: windows
+            goarch: arm64
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.24.0'
+
+      - name: Set up Git credentials for private modules
+        run: |
+          git config --global url."https://${{ secrets.GH_PAT }}@github.com/".insteadOf "https://github.com/"
+          echo "GOPRIVATE=github.com/tecamino/*" >> $GITHUB_ENV
+
+      - name: Build binary
+        run: |
+          mkdir -p build
+          if [ "${{ matrix.goos }}" == "windows" ]; then
+            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} go build -o build/tecamino-dbm-${{ matrix.goos }}-${{ matrix.goarch }}.exe main.go
+          else
+            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} go build -o build/tecamino-dbm-${{ matrix.goos }}-${{ matrix.goarch }} main.go
+          fi
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: build/

.gitignore

@@ -1 +1,3 @@
 .DS_Store
+*.dbm
+*.log

args/args.go

@@ -3,15 +3,15 @@ package args
 import (
 	"flag"
 
-	"github.com/zuadi/tecamino-dbm/cert"
+	"github.com/tecamino/tecamino-dbm/cert"
-	"github.com/zuadi/tecamino-dbm/models"
+	"github.com/tecamino/tecamino-dbm/models"
 )
 
 type Args struct {
 	Port    models.Port
 	Cert    cert.Cert
 	RootDir string
-	DMAFile string
+	DBMFile string
 	Debug   bool
 }
 
@@ -28,7 +28,7 @@ func Init() *Args {
 			Https: *flag.Uint("https-port", 8101, "json server communication for http/wss"),
 		},
 		RootDir: *flag.String("workingDir", "./", "working directory"),
-		DMAFile: *flag.String("dma", "/test/test", "dma file name"),
+		DBMFile: *flag.String("dbm", "/test/test", "dbm file name"),
 		Debug:   *flag.Bool("debug", false, "debug flag"),
 	}
 	flag.Parse()

auth/auth.go

@@ -13,3 +13,11 @@ func GetIDFromAuth(c *gin.Context) (string, error) {
 	}
 	return "", errors.New("authorization token missing")
 }
+
+func GetIDFromQuery(c *gin.Context) (string, error) {
+	auth, exists := c.GetQuery("id")
+	if !exists {
+		return "", errors.New("id missing")
+	}
+	return auth, nil
+}

cert/cert.go

@@ -29,11 +29,11 @@ func NewCertHandler(org string) *Cert {
 func (c *Cert) GenerateSelfSignedCert() error {
 
 	// do not generate certs if they exist
-	// _, err := os.Stat(c.CertFile)
+	_, err := os.Stat(c.CertFile)
-	// _, err2 := os.Stat(c.KeyFile)
+	_, err2 := os.Stat(c.KeyFile)
-	// if !os.IsNotExist(err) && !os.IsNotExist(err2) {
+	if !os.IsNotExist(err) && !os.IsNotExist(err2) {
-	// 	return nil
+		return nil
-	// }
+	}
 
 	priv, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {

dbm/db.go

@@ -0,0 +1,27 @@
+package dbm
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) SaveData(c *gin.Context) {
+	s := time.Now()
+	if err := d.SaveDb(); err != nil {
+		r := json_dataModels.NewResponse()
+		r.SetError()
+		r.SetMessage(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+
+		return
+	}
+
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("DBM %d datapoints saved in: %v", d.GetNumbersOfDatapoints(), time.Since(s)))
+	d.Log.Info("db.SaveData", fmt.Sprintf("DBM %d datapoints saved in: %v", d.GetNumbersOfDatapoints(), time.Since(s)))
+	c.JSON(http.StatusOK, r)
+}

dbm/dbmHandler.go

@@ -2,24 +2,23 @@ package dbm
 
 import (
 	"bufio"
-	"context"
 	"encoding/json"
 	"fmt"
 	"os"
-	"runtime"
 	"sync"
 	"time"
 
+	"github.com/tecamino/tecamino-dbm/args"
+	"github.com/tecamino/tecamino-dbm/models"
+	serverModels "github.com/tecamino/tecamino-dbm/server/models"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
 	"github.com/tecamino/tecamino-logger/logging"
-	"github.com/zuadi/tecamino-dbm/args"
-	"github.com/zuadi/tecamino-dbm/models"
-	serverModels "github.com/zuadi/tecamino-dbm/server/models"
 )
 
 type DBMHandler struct {
 	filePath string
 	DB       models.Datapoint
-	Clients  serverModels.Clients
+	Conns    *serverModels.Connections
 	sync.RWMutex
 	Log *logging.Logger
 	arg *args.Args
@@ -40,14 +39,14 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 	if err != nil {
 		return nil, err
 	}
-	logger.Info("main", "start dma")
+	logger.Info("main", "start dma handler")
 
 	// Initialize dtabase manager handler
 	dmaHandler := DBMHandler{
 		arg:      a,
-		filePath: fmt.Sprintf("%s/%s.dma", a.RootDir, a.DMAFile),
+		filePath: fmt.Sprintf("%s/%s.dbm", a.RootDir, a.DBMFile),
 		Log:      logger,
-		Clients:  serverModels.NewClients(),
+		Conns:    serverModels.NewConnections(),
 	}
 
 	// initialize system datapoint and periodically update it
@@ -56,6 +55,7 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 	}
 
 	// check if dtabase file exists to load data
+	s := time.Now()
 	if _, err := os.Stat(dmaHandler.filePath); err == nil {
 
 		f, err := os.Open(dmaHandler.filePath)
@@ -69,14 +69,13 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 
 		for scanner.Scan() {
 			dp := models.Datapoint{}
-			err = json.Unmarshal(scanner.Bytes(), &dp)
+			if err = json.Unmarshal(scanner.Bytes(), &dp); err != nil {
-			if err != nil {
 				return nil, err
 			}
-			dmaHandler.ImportDatapoints(&dp)
+			dmaHandler.ImportDatapoints(dp)
 		}
 	}
-
+	dmaHandler.Log.Info("dmbHandler.NewDmbHandler", fmt.Sprintf("%d datapoint imported in %v", dmaHandler.GetNumbersOfDatapoints(), time.Since(s)))
 	return &dmaHandler, nil
 }
 
@@ -105,93 +104,58 @@ func (d *DBMHandler) SaveDb() (err error) {
 	return
 }
 
-func (d *DBMHandler) CreateDatapoint(typ models.Type, value any, right models.Rights, path string) error {
+func (d *DBMHandler) CreateDatapoints(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
-	if err := d.DB.CreateDatapoint(typ, value, right, path); err != nil {
+	if len(sets) == 0 {
-		return err
+		return nil, nil
+	}
+
+	dps, err := d.DB.CreateDatapoints(d.Conns, sets...)
+	if err != nil {
+		return nil, err
+	}
+
+	var ndp uint64
+	for _, dp := range dps {
+		if !dp.Updated {
+			ndp++
+		}
 	}
 	dp := d.QueryDatapoints(1, "System:Datapoints")
-	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+ndp)
-	return nil
+	return dps, nil
 }
 
-func (d *DBMHandler) ImportDatapoints(dps ...*models.Datapoint) error {
+func (d *DBMHandler) ImportDatapoints(dps ...models.Datapoint) error {
 	for _, dp := range dps {
-		err := d.DB.ImportDatapoint(dp, dp.Path)
+		err := d.DB.ImportDatapoint(d.Conns, dp, dp.Path)
 		if err != nil {
 			return err
 		}
-		dp := d.QueryDatapoints(1, "System:Datapoints")
+		dps := d.QueryDatapoints(1, "System:Datapoints")
-		d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+		d.UpdateDatapointValue("System:Datapoints", dps[0].GetValueUint64()+1)
 	}
 	return nil
 }
 
 func (d *DBMHandler) UpdateDatapointValue(path string, value any) error {
-	return d.DB.UpdateDatapointValue(value, path)
+	return d.DB.UpdateDatapointValue(d.Conns, value, path)
 }
 
-func (d *DBMHandler) RemoveDatapoint(path string) error {
+func (d *DBMHandler) RemoveDatapoint(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
-	if err := d.DB.RemoveDatapoint(path); err != nil {
+	var lsRemoved []json_dataModels.Set
-		return err
+	for _, set := range sets {
+		removed, err := d.DB.RemoveDatapoint(d.Conns, set)
+		if err != nil {
+			return lsRemoved, err
 		}
+		lsRemoved = append(lsRemoved, removed)
 		dp := d.QueryDatapoints(1, "System:Datapoints")
-	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+		d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()-1)
-	return nil
+	}
+
+	return lsRemoved, nil
 }
 
-func (d *DBMHandler) QueryDatapoints(depth int, key string) []*models.Datapoint {
+func (d *DBMHandler) QueryDatapoints(depth uint, key string) []*models.Datapoint {
 	return d.DB.QueryDatapoints(depth, key)
 }
-
-func (d *DBMHandler) AddSystemDps() (err error) {
-	tim := "System:Time"
-	memory := "System:UsedMemory"
-	var m runtime.MemStats
-	var mOld uint64
-	var tOld int64
-
-	err = d.DB.CreateDatapoint(models.LOU, 0, models.Read, "System:Datapoints")
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-
-	err = d.DB.CreateDatapoint(models.STR, nil, models.Read, tim)
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-	err = d.DB.CreateDatapoint(models.STR, nil, models.Read, memory)
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-
-	go func() {
-
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
-		defer cancel()
-
-		for {
-			t := time.Now().UnixMilli()
-			if tOld != t {
-				if er := d.DB.UpdateDatapointValue(t, tim); er != nil {
-					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
-				}
-				d.Publish(ctx, OnChange, tim, t)
-				tOld = t
-			}
-			runtime.ReadMemStats(&m)
-			if m.Sys != mOld {
-				mem := fmt.Sprintf("%.2f MB", float64(m.Sys)/1024/1024)
-				if er := d.DB.UpdateDatapointValue(mem, memory); er != nil {
-					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
-				}
-				d.Publish(ctx, OnChange, memory, mem)
-				mOld = m.Sys
-			}
-			time.Sleep(1 * time.Second)
-		}
-	}()
-	return
-}

dbm/get.go

@@ -0,0 +1,39 @@
+package dbm
+
+import (
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) Get(req *json_dataModels.Request, id string) {
+	if req == nil {
+		return
+	} else if len(req.Get) == 0 {
+		return
+	}
+	d.RLock()
+	defer d.RUnlock()
+
+	resp := json_data.NewResponse()
+	resp.Id = req.Id
+	for _, get := range req.Get {
+		var depth uint = 1
+		if get.Query != nil {
+			depth = get.Query.Depth
+		}
+
+		for _, dp := range d.DB.QueryDatapoints(depth, get.Path) {
+			resp.AddGet(json_dataModels.Get{
+				Uuid:   dp.Uuid,
+				Path:   dp.Path,
+				Type:   dp.Type,
+				Value:  dp.Value,
+				Rights: dp.ReadWrite,
+			})
+		}
+	}
+
+	if err := d.Conns.SendResponse(id, resp); err != nil {
+		d.Log.Error("get.Get", err.Error())
+	}
+}

dbm/json_data.go

@@ -0,0 +1,84 @@
+package dbm
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) Json_Data(c *gin.Context) {
+	var err error
+	payload, err := json_data.ParseRequest(c.Request.Body)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	respond := json_dataModels.NewResponse()
+
+	if payload.Get != nil {
+		var depth uint = 1
+		for _, get := range payload.Get {
+			if get.Query != nil {
+				depth = get.Query.Depth
+			}
+
+			for _, res := range d.QueryDatapoints(depth, get.Path) {
+				respond.AddGet(json_dataModels.Get{
+					Uuid:    res.Uuid,
+					Path:    res.Path,
+					Type:    res.Type,
+					Value:   res.Value,
+					Rights:  res.ReadWrite,
+					Drivers: &res.Drivers,
+				})
+			}
+		}
+
+	}
+	if payload.Set != nil {
+		respond.Set, err = d.CreateDatapoints(payload.Set...)
+		if err != nil {
+			r := json_data.NewResponse()
+			r.SetError()
+			r.SetMessage(err.Error())
+			c.JSON(http.StatusBadRequest, r)
+			return
+		}
+	}
+
+	c.JSON(200, respond)
+}
+
+func (d *DBMHandler) Delete(c *gin.Context) {
+	var err error
+	payload, err := json_data.ParseRequest(c.Request.Body)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	response := json_data.NewResponse()
+
+	if payload.Set != nil {
+
+		response.Set, err = d.RemoveDatapoint(payload.Set...)
+		if err != nil {
+			r := json_data.NewResponse()
+			r.SetError()
+			r.SetMessage(err.Error())
+			c.JSON(http.StatusBadRequest, r)
+			return
+		}
+	}
+
+	c.JSON(200, response)
+}

dbm/publish.go

@@ -1,34 +0,0 @@
-package dbm
-
-import (
-	"context"
-
-	"github.com/coder/websocket/wsjson"
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func (d *DBMHandler) Publish(ctx context.Context, eventType, path string, value any) error {
-	d.RLock()
-	defer d.RUnlock()
-
-	for _, dp := range d.DB.QueryDatapoints(1, path) {
-		for id, pub := range dp.Subscribtions {
-			if client, ok := d.Clients[id]; !ok {
-				delete(dp.Subscribtions, id)
-			} else {
-				if pub.OnChange {
-					err := wsjson.Write(ctx, client.Conn, models.JsonResponse{
-						Event: OnChange,
-						Path:  dp.Path,
-						Value: value,
-					})
-					if err != nil {
-						d.Log.Error("publish.Publish", err.Error())
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
-}

dbm/set.go

@@ -0,0 +1,21 @@
+package dbm
+
+import (
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) Set(req *json_dataModels.Request) {
+	if req == nil {
+		return
+	} else if len(req.Set) == 0 {
+		return
+	}
+	d.RLock()
+	defer d.RUnlock()
+
+	for _, set := range req.Set {
+		for _, dp := range d.DB.QueryDatapoints(1, set.Path) {
+			dp.UpdateValue(d.Conns, set.Value)
+		}
+	}
+}

dbm/subscribe.go

@@ -1,46 +1,71 @@
 package dbm
 
 import (
-	"github.com/coder/websocket/wsjson"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
-	"github.com/zuadi/tecamino-dbm/models"
-	"golang.org/x/net/context"
 )
 
-func (d *DBMHandler) Subscribe(ctx context.Context, sub *models.Subscribe, id string) {
+func (d *DBMHandler) Subscribe(req *json_dataModels.Request, id string) {
+	if req == nil {
+		return
+	}
+	if len(req.Subscribe) == 0 {
+		return
+	}
 	d.RLock()
 	defer d.RUnlock()
 
+	resp := json_dataModels.NewResponse()
+	resp.Id = req.Id
+
+	for _, sub := range req.Subscribe {
 		for _, dp := range d.DB.QueryDatapoints(sub.Depth, sub.Path) {
-		if sub.Driver != nil {
+			if sub.Driver != "" {
-			if dp.Drivers == nil {
+				if dp.Drivers == nil || dp.Drivers[sub.Driver] == nil {
-				continue
-			} else if _, ok := dp.Drivers[*sub.Driver]; !ok {
 					continue
 				}
 			}
-
 			dp.AddSubscribtion(id, sub)
-
+			resp.AddSubscription(json_dataModels.Subscription{
-		err := wsjson.Write(ctx, d.Clients[id].Conn, models.JsonResponse{
+				Uuid:    dp.Uuid,
-			Event: OnCreate,
 				Path:    dp.Path,
 				Value:   dp.Value,
+				Driver:  sub.Driver,
+				Drivers: &dp.Drivers,
 			})
-		if err != nil {
-			d.Log.Error("subscribe.Subscribe", err.Error())
 		}
 	}
+
+	if err := d.Conns.SendResponse(id, resp); err != nil {
+		d.Log.Error("subscribe.Subscribe", err.Error())
+	}
 }
 
-func (d *DBMHandler) Unsubscribe(ctx context.Context, sub *models.Subscribe, id string) error {
+func (d *DBMHandler) Unsubscribe(req *json_dataModels.Request, id string) {
+	if req == nil {
+		return
+	}
+	if len(req.Unsubscribe) == 0 {
+		return
+	}
 	d.RLock()
 	defer d.RUnlock()
 
+	resp := json_dataModels.NewResponse()
+
+	for _, sub := range req.Unsubscribe {
 		for _, dp := range d.DB.QueryDatapoints(sub.Depth, sub.Path) {
-		if _, ok := dp.Subscribtions[id]; !ok {
+			if _, ok := dp.Subscriptions[id]; !ok {
 				continue
 			}
 			dp.RemoveSubscribtion(id)
+			resp.AddUnsubscription(json_dataModels.Subscription{
+				Uuid: dp.Uuid,
+				Path: dp.Path,
+			})
+		}
+	}
+
+	if err := d.Conns.SendResponse(id, resp); err != nil {
+		d.Log.Error("subscribe.Unsubscribe", err.Error())
 	}
-	return nil
 }

dbm/system.go

@@ -0,0 +1,97 @@
+package dbm
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+
+	"github.com/tecamino/tecamino-dbm/utils"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) AddSystemDps() (err error) {
+	path := "System:Datapoints"
+
+	typ := json_dataModels.LOU
+	rights := json_dataModels.Read
+	_, err = d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Value: 0, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("dmb.Handler.AddSystemDps", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, path)
+	d.UpdateDatapointValue(path, dp[0].GetValueUint64()+1)
+
+	if err = d.GoSystemTime(); err != nil {
+		return err
+	}
+
+	if err = d.GoSystemMemory(); err != nil {
+		return err
+	}
+	return
+}
+
+func (d *DBMHandler) GetNumbersOfDatapoints() uint64 {
+	return utils.Uint64From(d.DB.Datapoints["System"].Datapoints["Datapoints"].Value)
+}
+
+func (d *DBMHandler) GoSystemTime() error {
+	path := "System:Time"
+	var tOld int64
+
+	typ := json_dataModels.STR
+	rights := json_dataModels.Read
+	_, err := d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("system.GoSystemTime", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, "System:Datapoints")
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+
+	go func() {
+		for {
+			t := time.Now().UnixMilli()
+			if tOld != t {
+				if er := d.DB.UpdateDatapointValue(d.Conns, time.UnixMilli(t).Format("2006-01-02 15:04:05"), path); er != nil {
+					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
+				}
+				tOld = t
+			}
+			time.Sleep(time.Second)
+		}
+	}()
+	return nil
+}
+
+func (d *DBMHandler) GoSystemMemory() error {
+	path := "System:UsedMemory"
+	var m runtime.MemStats
+	var mOld uint64
+
+	typ := json_dataModels.STR
+	rights := json_dataModels.Read
+	_, err := d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("system.GoSystemMemory", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, "System:Datapoints")
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+
+	go func() {
+		for {
+			runtime.ReadMemStats(&m)
+			if m.Sys != mOld {
+				mem := fmt.Sprintf("%.2f MB", float64(m.Sys)/1024/1024)
+				if er := d.DB.UpdateDatapointValue(d.Conns, mem, path); er != nil {
+					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
+				}
+				mOld = m.Sys
+			}
+			time.Sleep(time.Second)
+		}
+	}()
+	return nil
+}

dbm/webSocket.go

@@ -1,13 +1,15 @@
 package dbm
 
 import (
-	"context"
+	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
 
 	"github.com/coder/websocket"
-	"github.com/coder/websocket/wsjson"
 	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/models"
+	"github.com/tecamino/tecamino-dbm/auth"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
 )
 
 const (
@@ -17,62 +19,63 @@ const (
 )
 
 func (d *DBMHandler) WebSocket(c *gin.Context) {
-	// id, err := auth.GetIDFromAuth(c)
+	id, err := auth.GetIDFromQuery(c)
-	// if err != nil {
+	if err != nil {
-	// 	d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
+		d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromQuery: "+err.Error())
-	// 	return
+		return
-	// }
+	}
-	id := "test"
-
 	d.Log.Debug("dbmHandler.webSocket.Websocket", "authorization id token: "+id)
 
-	ctx, cancel := context.WithCancel(c.Request.Context())
+	err = d.Conns.ConnectRecievingWsConnection(id, c)
-	defer cancel()
+	defer d.Conns.RemoveClient(id)
-	err := d.Clients.ConnectRecievingWsConnection(id, c)
-	defer d.Clients.RemoveClient(id)
 	if err != nil {
 		d.Log.Error("dbmHandler.webSocket.Websocket", "error connecting recieving websocket conection: "+err.Error())
 		return
 	}
-	defer d.Clients.DisconnectWsConnection(id, websocket.StatusInternalError, "Internal error")
+	defer d.Conns.DisconnectWsConnection(id, websocket.StatusInternalError, "Internal error")
 
 	//Read loop
 	for {
-		request, err := d.readJsonData(ctx, id)
+
+		request, err := d.readJsonData(id)
 		if err != nil {
+			d.Log.Error("websocket.WebSocket", err.Error())
 			break
 		}
 
+		// Sets
+
+		d.Get(request, id)
+		// Sets
+		d.Set(request)
+
 		// Subscribe
-
+		d.Subscribe(request, id)
-		if request.Subscribe != nil {
-			go func() {
-				for _, sub := range *request.Subscribe {
-					d.Subscribe(ctx, &sub, id)
-				}
-			}()
-		}
 
 		// Unsubscribe
-		if request.Unsubscribe != nil {
+		d.Unsubscribe(request, id)
-			for _, unsub := range *request.Unsubscribe {
-				err = d.Unsubscribe(ctx, &unsub, id)
-				if err != nil {
-					d.Log.Error("dbmHandler.WebSocket unsubscribe", err)
-					break
-				}
-			}
-		}
 
-		if err != nil {
+		request.Get = make([]json_dataModels.Get, 0)
-			break
+		request.Set = make([]json_dataModels.Set, 0)
-		}
+		request.Subscribe = make([]json_dataModels.Subscription, 0)
+		request.Unsubscribe = make([]json_dataModels.Subscription, 0)
+		request = nil
 	}
 }
 
-func (d *DBMHandler) readJsonData(ctx context.Context, id string) (*models.JsonData, error) {
+func (d *DBMHandler) readJsonData(id string) (request *json_dataModels.Request, err error) {
-	var request models.JsonData
+
-	err := wsjson.Read(ctx, d.Clients[id].Conn, &request)
+	client, ok := d.Conns.Clients[id]
+	if !ok {
+		return request, errors.New("client id not found")
+	}
+
+	_, reader, err := client.Conn.Reader(client.Ctx)
+	if err != nil {
+		return request, err
+	}
+
+	b, err := io.ReadAll(reader)
 	if err != nil {
 		code := websocket.CloseStatus(err)
 
@@ -81,11 +84,16 @@ func (d *DBMHandler) readJsonData(ctx context.Context, id string) (*models.JsonD
 			websocket.StatusGoingAway,
 			websocket.StatusNoStatusRcvd:
 			d.Log.Info("webSocket.readJsonData", fmt.Sprintf("WebSocket closed: %v (code: %v)\n", err, code))
-			return nil, err
+			return
 		default:
 			d.Log.Error("webSocket.readJsonData", fmt.Sprintf("WebSocket read error: %v (code: %v)\n", err, code))
-			return nil, err
+			return
 		}
 	}
-	return &request, nil
+
+	if err := json.Unmarshal(b, &request); err != nil {
+		return request, err
+	}
+
+	return
 }

dbmServer.log

@@ -1,560 +0,0 @@
-{"level":"info","timestamp":"2025-04-23T08:02:12.084","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:02:12.348","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps"}
-{"level":"info","timestamp":"2025-04-23T08:02:12.348","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:02:12.348","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:02:12.566","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps"}
-{"level":"error","timestamp":"2025-04-23T08:02:13.834","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps"}
-{"level":"error","timestamp":"2025-04-23T08:02:14.031","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps"}
-{"level":"info","timestamp":"2025-04-23T08:03:55.063","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:03:55.346","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:03:55.347","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:03:55.347","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:03:55.554","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:03:56.853","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:03:57.041","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:05:18.061","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:05:18.332","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:05:18.332","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:05:18.332","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:05:18.538","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:05:19.842","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:05:21.010","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:06:19.179","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:06:19.439","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:06:19.439","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:06:19.439","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:06:19.617","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:06:20.861","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:07:45.597","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:07:45.879","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:07:45.879","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:07:45.879","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:07:46.160","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:07:47.447","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:08:23.028","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:08:23.295","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:08:23.296","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:08:23.296","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:08:23.474","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:08:24.714","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:09:06.062","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:09:06.326","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:09:06.326","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:09:06.326","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:09:06.534","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:09:07.841","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:09:08.005","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:09:29.794","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:09:30.036","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:09:30.037","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:09:30.037","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:09:30.208","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:09:31.467","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:10:00.754","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:10:01.044","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:10:01.045","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:10:01.045","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:10:01.248","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:10:02.507","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:11:50.298","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:11:50.570","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:11:50.570","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:11:50.570","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:11:50.768","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:11:52.046","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:11:52.222","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:14:17.351","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:14:48.221","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:15:28.790","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:16:02.029","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:16:02.037","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:16:02.037","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:16:02.037","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:16:02.037","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:16:03.038","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:16:04.038","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:16:05.038","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:17:30.755","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:17:30.765","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:17:30.765","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:17:30.765","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:17:30.766","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:17:31.767","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:17:31.768","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:17:32.768","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:17:33.770","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:18:37.367","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:18:37.374","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:18:37.374","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:18:37.374","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:18:37.375","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:18:38.376","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:18:38.377","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:19:02.577","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:19:02.584","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:19:02.585","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:19:02.585","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:19:02.586","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:19:03.588","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:22:01.802","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:22:01.809","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:22:01.809","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:22:01.809","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:22:01.809","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:22:02.811","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:22:02.811","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:23:09.752","msg":"start dma","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:23:09.759","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:23:09.759","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:23:09.759","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:23:09.760","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:23:10.762","msg":"datapoint 'System:Time' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"error","timestamp":"2025-04-23T08:23:10.763","msg":"datapoint 'System:UsedMemory' not found","caller":"dmb.Handler.AddSystemDps.UpdateDatapointValue"}
-{"level":"info","timestamp":"2025-04-23T08:24:46.880","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:24:46.889","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:24:46.889","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:25:26.842","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:25:35.344","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:26:04.855","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T08:26:53.623","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:26:53.630","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:26:53.630","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:26:57.252","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T08:28:05.758","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:28:05.765","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:28:05.765","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:28:22.491","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:36:30.757","msg":"error GetIDFromAuth: authorization token missing","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T08:37:09.352","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:37:09.360","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:37:09.360","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:38:28.101","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:38:34.491","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:38:36.178","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:38:37.265","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T08:39:48.364","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:39:48.371","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:39:48.371","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:39:52.813","msg":"read error:failed to read JSON message: failed to unmarshal JSON: invalid character ':' after array element","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T08:39:56.608","msg":"read error:failed to read JSON message: failed to unmarshal JSON: invalid character ':' after array element","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T08:41:31.574","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:41:31.582","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:41:31.582","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:42:38.600","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:42:38.607","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:42:38.607","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:43:56.663","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:43:56.669","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:43:56.669","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:44:19.860","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:44:19.868","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:44:19.868","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:46:59.540","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:46:59.548","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T08:46:59.548","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T08:48:07.605","msg":"read error:failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\"","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T09:36:14.713","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:36:14.720","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:36:14.720","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:38:52.202","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:38:52.209","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:38:52.209","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:41:53.037","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:41:53.044","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:41:53.044","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:43:35.980","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:43:35.986","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:43:35.986","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T09:44:07.385","msg":"read error:failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\"","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T09:45:56.213","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:45:56.221","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:45:56.221","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:47:40.184","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:47:40.193","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T09:47:40.193","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:05:31.052","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:05:31.304","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:05:31.304","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:12:24.313","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:12:24.571","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:12:24.571","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T12:20:28.805","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T12:20:48.504","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T12:22:08.000","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T12:24:00.791","msg":"read error:failed to read JSON message: failed to get reader: use of closed network connection","caller":"artNet.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T12:24:25.263","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:24:25.517","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:24:25.517","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:42:11.099","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:42:11.364","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:42:11.364","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T12:45:18.145","msg":"read error:failed to read JSON message: failed to get reader: context deadline exceeded","caller":"dbmHandler.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T12:48:43.020","msg":"read error:failed to read JSON message: failed to get reader: context deadline exceeded","caller":"dbmHandler.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T12:49:40.208","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:49:40.486","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:49:40.486","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:55:05.401","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:55:05.671","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T12:55:05.671","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T12:58:11.602","msg":"read error:failed to read JSON message: failed to get reader: context deadline exceeded","caller":"dbmHandler.webSocket.Websocket"}
-{"level":"error","timestamp":"2025-04-23T13:08:06.888","msg":"read error:failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\"","caller":"dbmHandler.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T13:09:04.736","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:09:05.042","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:09:05.042","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T13:09:10.775","msg":"read error:failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\"","caller":"dbmHandler.webSocket.Websocket"}
-{"level":"info","timestamp":"2025-04-23T13:22:27.316","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:22:27.673","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:22:27.673","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:22:48.485","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"error","timestamp":"2025-04-23T13:23:26.354","msg":"failed to write JSON message: failed to marshal JSON: failed to write msg: use of closed network connection","caller":"publish.Publish"}
-{"level":"info","timestamp":"2025-04-23T13:23:40.800","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:23:41.121","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:23:41.121","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:23:45.546","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:26:22.134","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:26:22.395","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:26:22.396","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:26:27.705","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:28:49.207","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:28:49.481","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:28:49.481","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:28:54.557","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"error","timestamp":"2025-04-23T13:28:56.630","msg":"WebSocket read error: failed to read JSON message: failed to get reader: use of closed network connection (code: StatusCode(-1))\n","caller":"webSocket.readJsonData"}
-{"level":"error","timestamp":"2025-04-23T13:28:58.939","msg":"WebSocket read error: failed to read JSON message: failed to get reader: use of closed network connection (code: StatusCode(-1))\n","caller":"webSocket.readJsonData"}
-{"level":"error","timestamp":"2025-04-23T13:29:00.193","msg":"WebSocket read error: failed to read JSON message: failed to get reader: use of closed network connection (code: StatusCode(-1))\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:29:48.517","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:29:48.779","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:29:48.779","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:29:55.335","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:30:20.462","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:30:20.783","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:30:20.783","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:30:28.263","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:30:36.849","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T13:38:08.451","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:38:08.756","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:38:08.756","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:39:36.799","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:39:37.075","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:39:37.075","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:40:44.651","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:40:44.973","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:40:44.973","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:41:54.047","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:41:54.352","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:41:54.352","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:54:32.110","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:54:32.407","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:54:32.408","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:55:49.618","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:55:49.900","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:55:49.900","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:56:34.529","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:56:34.860","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:56:34.860","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:00.522","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:00.823","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:00.823","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:22.103","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:22.367","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T13:57:22.367","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:05.868","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:06.135","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:06.135","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:29.804","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:30.055","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:30.055","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:39.419","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:39.753","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:00:39.753","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:01:26.135","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:01:26.431","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:01:26.431","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:07.851","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:08.136","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:08.136","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:36.620","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:36.922","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:02:36.922","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:03:44.025","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:03:44.292","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:03:44.292","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:04:32.978","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T14:05:24.731","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:05:25.011","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:05:25.011","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:06:00.079","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T14:06:06.589","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T14:06:46.334","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:06:46.629","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:06:46.629","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:09:01.329","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:09:01.638","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:09:01.638","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:11:10.493","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:11:10.793","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:11:10.798","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:14:33.137","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:14:33.407","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:14:33.407","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:16:47.484","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:16:47.778","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:16:47.778","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:18:29.845","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:18:30.159","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:18:30.159","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:19:09.524","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:19:09.847","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:19:09.847","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:05.124","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:05.395","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:05.395","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:38.789","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:39.079","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:21:39.079","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:02.321","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:02.597","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:02.598","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:17.086","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:17.405","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:22:17.405","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:24:08.156","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:24:08.431","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:24:08.431","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:41:40.222","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:41:40.522","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:41:40.522","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:33.463","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:33.816","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:33.816","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:55.048","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:55.333","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:42:55.333","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:44:23.194","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:44:23.478","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:44:23.478","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:48:31.721","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:48:32.003","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:48:32.003","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:50:44.138","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:50:44.434","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:50:44.434","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:52:27.355","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:52:27.657","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T14:52:27.657","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:13:04.232","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:13:04.511","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:13:04.511","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:14.199","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:14.529","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:14.529","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:47.927","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:48.213","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:14:48.213","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:15:55.558","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:15:55.856","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:15:55.856","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:18:06.585","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:18:06.896","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:18:06.896","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:19:48.203","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:19:48.560","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:19:48.560","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:21:47.452","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:21:47.731","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:21:47.731","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:22:26.167","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:22:26.453","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:22:26.453","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:24:30.840","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:24:31.154","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:24:31.154","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:25:21.097","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:25:21.448","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:25:21.448","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:26:19.462","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:26:19.770","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:26:19.770","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:27:56.148","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:27:56.425","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:27:56.425","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:29:19.768","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:29:20.055","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:29:20.055","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:30:37.990","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:30:38.306","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:30:38.306","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:04.614","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:04.872","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:04.872","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:42.125","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:42.405","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:33:42.405","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:35:29.364","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:35:29.645","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:35:29.645","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:36:27.148","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:36:27.439","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:36:27.439","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:37:26.182","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:37:26.468","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:37:26.468","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:39:44.950","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:39:45.259","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:39:45.259","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:42:56.735","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:42:57.000","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:42:57.000","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:44:07.340","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:44:07.617","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:44:07.617","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:49:39.704","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:49:40.013","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:49:40.013","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:50:33.848","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:50:58.614","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:51:15.662","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:51:29.317","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T15:51:37.704","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:08:38.719","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:09:00.713","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:09:01.005","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:09:01.005","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:13:13.940","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:13:14.214","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:13:14.214","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:14.715","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:15.003","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:15.003","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:44.461","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:44.726","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:15:44.726","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:16:37.294","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:16:37.634","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:16:37.634","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:12.883","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:13.188","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:13.188","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:36.481","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:36.753","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:17:36.753","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:18:35.785","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:18:36.060","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:18:36.060","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:19:18.201","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:19:18.472","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:19:18.472","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:00.617","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:00.931","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:00.931","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:29.238","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:29.523","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:20:29.523","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:12.711","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:12.995","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:12.995","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:46.808","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:47.089","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:21:47.089","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:24:34.513","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:24:34.766","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:24:34.767","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:08.863","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:09.125","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:09.125","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:20.500","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:20.758","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:25:20.758","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:26:35.367","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:26:35.640","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:26:35.640","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:27:24.719","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:27:25.026","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:27:25.026","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:28:45.695","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:28:45.978","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:28:45.978","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:33:31.621","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:33:31.908","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:33:31.908","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:29.559","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:29.827","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:29.827","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:54.193","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:54.523","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:40:54.525","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:41:50.625","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T16:42:41.188","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:42:41.483","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:42:41.483","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:26.920","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:27.222","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:27.222","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:46.937","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:47.210","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:47.211","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:43:57.348","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T16:44:18.299","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:44:18.584","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:44:18.584","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:47:28.208","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:47:28.525","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:47:28.525","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:55:08.835","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:55:09.098","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:55:09.098","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:56:37.960","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:56:38.242","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:56:38.242","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:58:01.228","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:58:01.513","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:58:01.513","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:59:20.426","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:59:20.707","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T16:59:20.707","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:12:15.307","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:12:16.391","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:12:16.391","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:13:58.319","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T17:14:39.566","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:14:40.644","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:14:40.644","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:15:48.856","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:15:50.428","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:15:50.428","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:16:59.161","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T17:17:54.578","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:17:55.858","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:17:55.858","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:19:30.348","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"error","timestamp":"2025-04-23T17:19:30.348","msg":"failed to write JSON message: failed to marshal JSON: failed to write msg: use of closed network connection","caller":"subscribe.Subscribe"}
-{"level":"info","timestamp":"2025-04-23T17:19:43.223","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:19:44.757","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:19:44.757","msg":"http listen on 8100","caller":"main"}
-{"level":"error","timestamp":"2025-04-23T17:20:07.653","msg":"WebSocket read error: failed to read JSON message: failed to unmarshal JSON: invalid character ',' looking for beginning of value (code: StatusCode(-1))\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T17:20:17.815","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusNoStatusRcvd and reason = \"\" (code: StatusNoStatusRcvd)\n","caller":"webSocket.readJsonData"}
-{"level":"info","timestamp":"2025-04-23T17:22:06.954","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:22:08.494","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:22:08.494","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:22:49.284","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:22:50.545","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:22:50.545","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:23:21.885","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:23:23.201","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:23:23.201","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:24:20.189","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:24:21.524","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:24:21.524","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:09.915","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:10.999","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:10.999","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:48.721","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:49.832","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:31:49.832","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:33:31.847","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:33:32.898","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:33:32.898","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:35:01.005","msg":"start dma","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:35:02.192","msg":"https listen on 8101","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:35:02.192","msg":"http listen on 8100","caller":"main"}
-{"level":"info","timestamp":"2025-04-23T17:36:14.186","msg":"WebSocket closed: failed to read JSON message: failed to get reader: received close frame: status = StatusGoingAway and reason = \"\" (code: StatusGoingAway)\n","caller":"webSocket.readJsonData"}

go.mod

@@ -1,12 +1,13 @@
-module github.com/zuadi/tecamino-dbm
+module github.com/tecamino/tecamino-dbm
 
 go 1.24.0
 
 require (
 	github.com/coder/websocket v1.8.13
 	github.com/gin-gonic/gin v1.10.0
+	github.com/google/uuid v1.6.0
+	github.com/tecamino/tecamino-json_data v0.0.12
 	github.com/tecamino/tecamino-logger v0.2.0
-	golang.org/x/net v0.25.0
 )
 
 require (
@@ -33,6 +34,7 @@ require (
 	go.uber.org/zap v1.27.0 // indirect
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
 	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/text v0.15.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect

go.sum

@@ -30,6 +30,8 @@ github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MG
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
@@ -61,6 +63,8 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tecamino/tecamino-json_data v0.0.12 h1:S4Y+WcfQNrin7P73ZI+4eJWh62IwJVhriRsPGGM8N34=
+github.com/tecamino/tecamino-json_data v0.0.12/go.mod h1:LLlyD7Wwqplb2BP4PeO86EokEcTRidlW5MwgPd1T2JY=
 github.com/tecamino/tecamino-logger v0.2.0 h1:NPH/Gg9qRhmVoW8b39i1eXu/LEftHc74nyISpcRG+XU=
 github.com/tecamino/tecamino-logger v0.2.0/go.mod h1:0M1E9Uei/qw3e3WA1x3lBo1eP3H5oeYE7GjYrMahnj8=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=

main.go

@@ -4,19 +4,21 @@ import (
 	"fmt"
 
 	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/args"
+	"github.com/tecamino/tecamino-dbm/args"
-	"github.com/zuadi/tecamino-dbm/dbm"
+	"github.com/tecamino/tecamino-dbm/dbm"
-	"github.com/zuadi/tecamino-dbm/server"
+	"github.com/tecamino/tecamino-dbm/server"
 )
 
 func main() {
-	//cli arguments
+	// cli arguments
 	a := args.Init()
 
+	// initiate new database manger
 	dbmHandler, err := dbm.NewDbmHandler(a)
 	if err != nil {
 		panic(err)
 	}
+	//save database after exeutabe ends
 	defer dbmHandler.SaveDb()
 
 	//initialize new server
@@ -26,22 +28,27 @@ func main() {
 	//set routes
 	dbmHandler.Log.Debug("main", "setting routes")
 	s.Routes.GET("/ws", dbmHandler.WebSocket)
-	s.Routes.POST("/json_data", s.JsonRequest)
+	s.Routes.GET("/saveData", dbmHandler.SaveData)
-
+	s.Routes.POST("/json_data", dbmHandler.Json_Data)
+	s.Routes.DELETE("/json_data", dbmHandler.Delete)
 	s.Routes.GET("/", func(c *gin.Context) {
 		c.String(200, "DBM WebSocket Server is running!")
 	})
 
+	// start http server
 	go func() {
 		dbmHandler.Log.Info("main", fmt.Sprintf("http listen on %d", a.Port.Http))
-		// start http server
 		if err := s.ServeHttp(a.Port.Http); err != nil {
 			dbmHandler.Log.Error("main", "error http server "+err.Error())
 			panic(err)
 		}
 	}()
 
+	// start https server
 	dbmHandler.Log.Info("main", fmt.Sprintf("https listen on %d", a.Port.Https))
-	panic(s.ServeHttps(a.Port.Https, a.Cert))
+	if err := s.ServeHttps(a.Port.Https, a.Cert); err != nil {
+		dbmHandler.Log.Error("main", "error http server "+err.Error())
+		panic(err)
+	}
 
 }

models/datapoint.go

@@ -0,0 +1,393 @@
+package models
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	serverModels "github.com/tecamino/tecamino-dbm/server/models"
+	"github.com/tecamino/tecamino-dbm/utils"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+const (
+	OnCreate = "onCreate"
+	OnChange = "onChange"
+	OnDelete = "onDelete"
+)
+
+type Datapoint struct {
+	Datapoints     map[string]*Datapoint   `json:"-"`
+	Uuid           uuid.UUID               `json:"uuid"`
+	Path           string                  `json:"path"`
+	Value          any                     `json:"value,omitempty"`
+	CreateDateTime int64                   `json:"createDateTime,omitempty"`
+	UpdateDateTime int64                   `json:"updateDateTime,omitempty"`
+	Type           json_dataModels.Type    `json:"type"`
+	ReadWrite      json_dataModels.Rights  `json:"readWrite"`
+	Drivers        json_dataModels.Drivers `json:"drivers,omitempty"`
+	Subscriptions  Subscriptions           `json:"-"`
+}
+
+func (d *Datapoint) Set(path string, set json_dataModels.Set) (bool, error) {
+	var changed bool
+	if path != "" {
+		changed = true
+		d.Path = path
+	}
+
+	if set.Type != "" {
+		changed = true
+		d.Type = set.Type
+	}
+
+	if d.Type != "" {
+		if d.Value == nil && set.Value == nil {
+			changed = true
+			d.Value = d.Type.DefaultValue()
+		} else if d.Value != d.Type.ConvertValue(set.Value) {
+			changed = true
+			d.Value = d.Type.ConvertValue(set.Value)
+		}
+
+	}
+	if set.Rights != "" {
+		changed = true
+		d.ReadWrite = set.Rights.GetRights()
+	}
+
+	if changed {
+		d.UpdateDateTime = time.Now().UnixMilli()
+	}
+
+	if set.Driver == nil {
+		return changed, nil
+	}
+	if set.Driver.Type == "" {
+		return changed, errors.New("driver type missing")
+	}
+	if set.Driver.Bus == "" {
+		return changed, errors.New("driver bus name missing")
+	}
+
+	if d.Drivers == nil {
+		d.Drivers = json_dataModels.NewDrivers()
+	}
+	d.Drivers.AddDriver(set.Driver.Type, set.Driver.Bus, set.Driver.Address)
+	d.UpdateDateTime = time.Now().UnixMilli()
+
+	return changed, nil
+}
+
+func (d *Datapoint) GetValueUint64() uint64 {
+	return utils.Uint64From(d.Value)
+}
+
+func (d *Datapoint) CreateDatapoints(conns *serverModels.Connections, sets ...json_dataModels.Set) (created []json_dataModels.Set, err error) {
+	if len(sets) == 0 {
+		return
+	}
+	for _, dp := range sets {
+		parts := strings.Split(dp.Path, ":")
+
+		current := d
+		for i, part := range parts {
+			if current.Datapoints == nil {
+				current.Datapoints = make(map[string]*Datapoint)
+			}
+
+			if i == len(parts)-1 {
+				// Leaf node: create or update datapoint
+				if existing, ok := current.Datapoints[part]; ok {
+					publish, err := existing.Set("", dp)
+					if err != nil {
+						return nil, err
+					}
+					created = append(created, json_dataModels.Set{
+						Uuid:    existing.Uuid,
+						Path:    existing.Path,
+						Type:    existing.Type,
+						Value:   existing.Value,
+						Rights:  existing.ReadWrite,
+						Drivers: &existing.Drivers,
+						Updated: true,
+					})
+
+					if publish {
+						existing.Publish(conns, OnChange)
+					}
+				} else {
+					ndp := Datapoint{
+						Uuid:           uuid.New(),
+						CreateDateTime: time.Now().UnixMilli(),
+						Subscriptions:  InitSubscribtion(),
+					}
+					// Create new
+					current.Datapoints[part] = &ndp
+					publish, err := ndp.Set(strings.Join(parts, ":"), dp)
+					if err != nil {
+						return nil, err
+					}
+					created = append(created, json_dataModels.Set{
+						Uuid:   ndp.Uuid,
+						Path:   ndp.Path,
+						Type:   ndp.Type,
+						Value:  ndp.Value,
+						Rights: ndp.ReadWrite,
+						Driver: dp.Driver,
+					})
+					if publish {
+						current.Publish(conns, OnChange)
+					}
+				}
+			}
+
+			// Traverse or create intermediate datapoints
+			if next, ok := current.Datapoints[part]; ok {
+				current = next
+			} else {
+				newDp := &Datapoint{
+					Uuid:           uuid.New(),
+					Path:           strings.Join(parts[:i+1], ":"),
+					Type:           json_dataModels.NONE,
+					CreateDateTime: time.Now().UnixMilli(),
+					UpdateDateTime: time.Now().UnixMilli(),
+					Subscriptions:  InitSubscribtion(),
+				}
+
+				created = append(created, json_dataModels.Set{
+					Uuid:   newDp.Uuid,
+					Path:   newDp.Path,
+					Type:   newDp.Type,
+					Value:  newDp.Value,
+					Rights: newDp.ReadWrite,
+				})
+
+				if dp.Rights != "" {
+					newDp.ReadWrite = dp.Rights.GetRights()
+				}
+
+				current.Datapoints[part] = newDp
+				current = newDp
+			}
+		}
+	}
+	return
+}
+
+func (d *Datapoint) ImportDatapoint(conns *serverModels.Connections, dp Datapoint, path string) error {
+	parts := strings.Split(dp.Path, ":")
+
+	current := d
+	for i, part := range parts {
+		if current.Datapoints == nil {
+			current.Datapoints = make(map[string]*Datapoint)
+		}
+
+		if i == len(parts)-1 {
+			// Leaf node: import the datapoint
+			if existing, ok := current.Datapoints[part]; ok {
+				existing.Type = dp.Type
+				existing.Value = dp.Type.ConvertValue(dp.Value)
+				existing.ReadWrite = dp.ReadWrite.GetRights()
+				existing.UpdateDateTime = time.Now().UnixMilli()
+				dp.Publish(conns, OnChange)
+			} else {
+				dp.Path = strings.Join(parts, ":")
+				dp.ReadWrite = dp.ReadWrite.GetRights()
+				dp.UpdateDateTime = time.Now().UnixMilli()
+				dp.Subscriptions = InitSubscribtion()
+				current.Datapoints[part] = &dp
+				dp.Publish(conns, OnChange)
+			}
+			return nil
+		}
+
+		// Traverse or create intermediate nodes
+		if next, ok := current.Datapoints[part]; ok {
+			current = next
+		} else {
+			newDp := &Datapoint{
+				Path:           strings.Join(parts[:i+1], ":"),
+				Type:           json_dataModels.NONE,
+				ReadWrite:      dp.ReadWrite.GetRights(),
+				UpdateDateTime: time.Now().UnixMilli(),
+			}
+			newDp.ReadWrite = newDp.ReadWrite.GetRights()
+			current.Datapoints[part] = newDp
+			current = newDp
+		}
+	}
+	return nil
+}
+
+func (d *Datapoint) UpdateDatapointValue(conns *serverModels.Connections, value any, path string) error {
+
+	paths := strings.Split(path, ":")
+
+	current := d
+	for i, part := range paths {
+		dp, ok := current.Datapoints[part]
+		if !ok {
+			return fmt.Errorf("datapoint path not found: %s (at %s)", path, part)
+		}
+		if i == len(paths)-1 {
+			dp.Value = dp.Type.ConvertValue(value)
+			dp.UpdateDateTime = time.Now().UnixMilli()
+			dp.Publish(conns, OnChange)
+			return nil
+		}
+		current = dp
+	}
+	return nil
+}
+
+func (d *Datapoint) UpdateValue(conns *serverModels.Connections, value any) error {
+	d.Value = d.Type.ConvertValue(value)
+	d.UpdateDateTime = time.Now().UnixMilli()
+	d.Publish(conns, OnChange)
+	return nil
+}
+
+func (d *Datapoint) RemoveDatapoint(conns *serverModels.Connections, set json_dataModels.Set) (json_dataModels.Set, error) {
+	parts := strings.Split(set.Path, ":")
+
+	if len(parts) < 1 {
+		return json_dataModels.Set{}, fmt.Errorf("invalid path: '%s'", set.Path)
+	}
+
+	current := d
+	for i := range len(parts) - 1 {
+		next, ok := current.Datapoints[parts[i]]
+		if !ok {
+			return json_dataModels.Set{}, fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
+		}
+		current = next
+	}
+
+	toDelete := parts[len(parts)-1]
+	if dp, ok := current.Datapoints[toDelete]; ok {
+		dp.Publish(conns, OnDelete)
+		delete(current.Datapoints, toDelete)
+		return json_dataModels.Set{
+			Uuid: set.Uuid,
+			Path: set.Path,
+		}, nil
+	}
+	return json_dataModels.Set{}, fmt.Errorf("datapoint '%s' not found", set.Path)
+}
+
+func (d *Datapoint) GetAllDatapoints(depth uint) (dps Datapoints) {
+
+	var dfs func(dp *Datapoint, currentDepth uint)
+	dfs = func(dp *Datapoint, currentDepth uint) {
+		if depth == 1 {
+			return
+		} else if depth == 0 {
+			// Return all descendants
+			for _, child := range dp.Datapoints {
+				dps = append(dps, child)
+				dfs(child, currentDepth+1)
+			}
+			return
+		}
+
+		if currentDepth == depth-1 {
+			return
+		}
+
+		for _, child := range dp.Datapoints {
+			dps = append(dps, child)
+			dfs(child, currentDepth+1)
+		}
+	}
+	dps = append(dps, d)
+	dfs(d, 0)
+	dps.SortSlice()
+	return
+}
+
+func (d *Datapoint) QueryDatapoints(depth uint, path string) (dps Datapoints) {
+	parts := strings.Split(path, ":")
+
+	var dfs func(current *Datapoint, index int)
+	dfs = func(current *Datapoint, index int) {
+
+		if index == len(parts) {
+			dps = append(dps, current.GetAllDatapoints(depth)...)
+			return
+		}
+
+		pattern := "^" + parts[index] + "$"
+		re, err := regexp.Compile(pattern)
+		if err != nil {
+			return
+		}
+
+		for name, dp := range current.Datapoints {
+			if re.MatchString(name) {
+				dfs(dp, index+1)
+			}
+		}
+	}
+
+	dfs(d, 0)
+	dps.SortSlice()
+	return
+}
+
+func (d *Datapoint) AddSubscribtion(id string, sub json_dataModels.Subscription) {
+	if d.Subscriptions == nil {
+		return
+	}
+
+	if s, ok := d.Subscriptions[id]; ok {
+		s.OnCreate = sub.OnCreate
+		s.OnChange = sub.OnChange
+		s.OnDelete = sub.OnDelete
+	} else {
+		d.Subscriptions[id] = &Subscription{
+			OnCreate: sub.OnCreate,
+			OnChange: sub.OnChange,
+			OnDelete: sub.OnDelete,
+		}
+	}
+}
+
+func (d *Datapoint) RemoveSubscribtion(id string) {
+	if _, ok := d.Subscriptions[id]; !ok {
+		return
+	}
+	delete(d.Subscriptions, id)
+}
+
+func (d *Datapoint) Publish(conns *serverModels.Connections, eventType string) error {
+	if conns.Clients == nil {
+		return nil
+	}
+	conns.RLock()
+	defer conns.RUnlock()
+
+	for id := range d.Subscriptions {
+		if _, ok := conns.Clients[id]; !ok {
+			delete(d.Subscriptions, id)
+		} else {
+			r := json_data.NewResponse()
+			r.AddUPublish(json_dataModels.Publish{
+				Event: eventType,
+				Uuid:  d.Uuid,
+				Path:  d.Path,
+				Value: d.Value,
+			})
+
+			if err := conns.SendResponse(id, r); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

models/datapoints.go

@@ -1,277 +1,12 @@
 package models
 
-import (
+import "sort"
-	"fmt"
-	"regexp"
-	"strings"
-	"time"
 
-	"github.com/zuadi/tecamino-dbm/utils"
+type Datapoints []*Datapoint
-)
 
-type Datapoint struct {
+func (d *Datapoints) SortSlice() {
-	Datapoints     map[string]*Datapoint `json:"-"`
+	// Sort by Path before processing
-	Path           string                `json:"path"`
+	sort.Slice(*d, func(i, j int) bool {
-	Value          any                   `json:"value,omitempty"`
+		return (*d)[i].Path < (*d)[j].Path
-	CreateDateTime int64                 `json:"createDateTime,omitempty"`
+	})
-	UpdateDateTime int64                 `json:"updateDateTime,omitempty"`
-	Type           Type                  `json:"type"`
-	ReadWrite      Rights                `json:"readWrite"`
-	Drivers        map[string]*Driver    `json:"-"`
-	Subscribtions  Subscribtions         `json:"-"`
-}
-
-func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path string) error {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
-
-	current := d
-	for i, part := range parts {
-		if current.Datapoints == nil {
-			current.Datapoints = make(map[string]*Datapoint)
-		}
-
-		if i == len(parts)-1 {
-			// Leaf node: create or update datapoint
-			if existing, ok := current.Datapoints[part]; ok {
-				// Update existing
-				existing.Type = typ
-				existing.ReadWrite = rights.GetRights()
-				existing.Value = typ.ConvertValue(value)
-				existing.UpdateDateTime = time.Now().UnixMilli()
-			} else {
-				// Create new
-				current.Datapoints[part] = &Datapoint{
-					Path:           strings.Join(parts, ":"),
-					Type:           typ,
-					Value:          typ.ConvertValue(value),
-					ReadWrite:      rights.GetRights(),
-					CreateDateTime: time.Now().UnixMilli(),
-					UpdateDateTime: time.Now().UnixMilli(),
-					Subscribtions:  InitSubscribtion(),
-				}
-			}
-			return nil
-		}
-
-		// Traverse or create intermediate datapoints
-		if next, ok := current.Datapoints[part]; ok {
-			current = next
-		} else {
-			newDp := &Datapoint{
-				Path:           strings.Join(parts[:i+1], ":"),
-				Type:           NONE,
-				ReadWrite:      rights.GetRights(),
-				CreateDateTime: time.Now().UnixMilli(),
-				UpdateDateTime: time.Now().UnixMilli(),
-				Subscribtions:  InitSubscribtion(),
-			}
-			current.Datapoints[part] = newDp
-			current = newDp
-		}
-	}
-	return nil
-}
-
-func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
-
-	current := d
-	for i, part := range parts {
-		if current.Datapoints == nil {
-			current.Datapoints = make(map[string]*Datapoint)
-		}
-
-		if i == len(parts)-1 {
-			// Leaf node: import the datapoint
-			if existing, ok := current.Datapoints[part]; ok {
-				existing.Type = dp.Type
-				existing.Value = current.Type.ConvertValue(dp.Value)
-				existing.ReadWrite = dp.ReadWrite.GetRights()
-				existing.UpdateDateTime = time.Now().UnixMilli()
-			} else {
-				dp.Path = strings.Join(parts, ":")
-				dp.ReadWrite = dp.ReadWrite.GetRights()
-				dp.UpdateDateTime = time.Now().UnixMilli()
-				dp.Subscribtions = InitSubscribtion()
-				current.Datapoints[part] = dp
-			}
-			return nil
-		}
-
-		// Traverse or create intermediate nodes
-		if next, ok := current.Datapoints[part]; ok {
-			current = next
-		} else {
-			newDp := &Datapoint{
-				Path:           strings.Join(parts[:i+1], ":"),
-				Type:           NONE,
-				ReadWrite:      dp.ReadWrite.GetRights(),
-				UpdateDateTime: time.Now().UnixMilli(),
-			}
-			newDp.ReadWrite = newDp.ReadWrite.GetRights()
-			current.Datapoints[part] = newDp
-			current = newDp
-		}
-	}
-	return nil
-}
-
-func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
-
-	paths := regexp.MustCompile(`[:]+`).Split(path, -1)
-
-	current := d
-	for i, part := range paths {
-		dp, ok := current.Datapoints[part]
-		if !ok {
-			return fmt.Errorf("datapoint path not found: %s (at %s)", path, part)
-		}
-		if i == len(paths)-1 {
-			dp.Value = dp.Type.ConvertValue(value)
-			dp.UpdateDateTime = time.Now().UnixMilli()
-			return nil
-		}
-		current = dp
-	}
-	return nil
-}
-
-func (d *Datapoint) RemoveDatapoint(path string) error {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
-
-	if len(parts) < 1 {
-		return fmt.Errorf("invalid path: '%s'", path)
-	}
-
-	current := d
-	for i := range len(parts) - 1 {
-		next, ok := current.Datapoints[parts[i]]
-		if !ok {
-			return fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
-		}
-		current = next
-	}
-
-	toDelete := parts[len(parts)-1]
-	if _, ok := current.Datapoints[toDelete]; ok {
-		delete(current.Datapoints, toDelete)
-		fmt.Println("Removed datapoint:", path)
-		return nil
-	}
-
-	return fmt.Errorf("datapoint '%s' not found", path)
-}
-
-func (d *Datapoint) GetAllDatapoints(depth int) (dps []*Datapoint) {
-
-	var dfs func(dp *Datapoint, currentDepth int)
-	dfs = func(dp *Datapoint, currentDepth int) {
-		if currentDepth == 0 {
-			dps = append(dps, dp)
-		}
-
-		if depth == 1 {
-			return
-		} else if depth == 0 {
-			// Return all descendants
-			for _, child := range dp.Datapoints {
-				dps = append(dps, child)
-				dfs(child, currentDepth+1)
-			}
-			return
-		}
-
-		if currentDepth == depth-1 {
-			return
-		}
-
-		for _, child := range dp.Datapoints {
-			dfs(child, currentDepth+1)
-		}
-	}
-
-	dfs(d, 0)
-	return
-}
-
-func (d *Datapoint) QueryDatapoints(depth int, path string) (dps []*Datapoint) {
-	parts := strings.Split(path, ":")
-
-	var dfs func(current *Datapoint, index int)
-	dfs = func(current *Datapoint, index int) {
-
-		if index == len(parts) {
-			dps = append(dps, current.GetAllDatapoints(depth)...)
-			return
-		}
-
-		pattern := "^" + parts[index] + "$"
-		re, err := regexp.Compile(pattern)
-		if err != nil {
-			return
-		}
-
-		for name, dp := range current.Datapoints {
-			if re.MatchString(name) {
-				dfs(dp, index+1)
-			}
-		}
-	}
-
-	dfs(d, 0)
-	return
-}
-
-func (d *Datapoint) AddSubscribtion(id string, sub *Subscribe) {
-	if d.Subscribtions == nil {
-		return
-	}
-
-	if s, ok := d.Subscribtions[id]; ok {
-		s.OnCreate = sub.OnCreate
-		s.OnChange = sub.OnChange
-		s.OnDelete = sub.OnDelete
-	} else {
-		d.Subscribtions[id] = &Subscribtion{
-			OnCreate: sub.OnCreate,
-			OnChange: sub.OnChange,
-			OnDelete: sub.OnDelete,
-		}
-	}
-}
-
-func (d *Datapoint) RemoveSubscribtion(id string) {
-	if _, ok := d.Subscribtions[id]; !ok {
-		return
-	}
-	delete(d.Subscribtions, id)
-}
-
-func (d *Datapoint) AddDriver(driver, bus string, adr int) {
-	if d.Drivers == nil {
-		d.Drivers = make(map[string]*Driver)
-	}
-
-	d.Drivers[driver] = &Driver{
-		Bus:     bus,
-		Address: adr,
-	}
-}
-
-func (d *Datapoint) AddDriverSubscribtion(id string, sub *Subscribe) {
-	if s, ok := d.Subscribtions[id]; ok {
-		s.OnCreate = sub.OnCreate
-		s.OnChange = sub.OnChange
-		s.OnDelete = sub.OnDelete
-	} else {
-		d.Subscribtions[id] = &Subscribtion{
-			OnCreate: sub.OnCreate,
-			OnChange: sub.OnChange,
-			OnDelete: sub.OnDelete,
-		}
-	}
-}
-
-func (d *Datapoint) GetValueUint64() uint64 {
-	return utils.Uint64From(d.Value)
 }

models/driver.go

@@ -1,6 +0,0 @@
-package models
-
-type Driver struct {
-	Bus     string
-	Address int
-}

models/get.go

@@ -1,6 +0,0 @@
-package models
-
-type Get struct {
-	Path  string `json:"path"`
-	Query *Query `json:"query,omitempty"`
-}

models/jsonData.go

@@ -1,35 +0,0 @@
-package models
-
-type JsonData struct {
-	Get         *[]Get       `json:"get,omitempty"`
-	Set         *[]Set       `json:"set,omitempty"`
-	Subscribe   *[]Subscribe `json:"subscribe,omitempty"`
-	Unsubscribe *[]Subscribe `json:"unsubscribe,omitempty"`
-}
-
-func NewRequest() *JsonData {
-	return &JsonData{}
-
-}
-
-func (r *JsonData) AddGet(path string, query Query) {
-	if r.Get == nil {
-		r.Get = &[]Get{}
-	}
-
-	*r.Get = append(*r.Get, Get{
-		Path:  path,
-		Query: &query,
-	})
-}
-
-func (r *JsonData) AddSet(path string, value any, create bool) {
-	if r.Set == nil {
-		r.Set = &[]Set{}
-	}
-
-	*r.Set = append(*r.Set, Set{
-		Path:  path,
-		Value: value,
-	})
-}

models/jsonResponse.go

@@ -1,10 +0,0 @@
-package models
-
-type JsonResponse struct {
-	Error   *bool  `json:"error,omitempty"`
-	Message string `json:"message,omitempty"`
-	Data    string `json:"data,omitempty"`
-	Event   string `json:"event,omitempty"`
-	Path    string `json:"path,omitempty"`
-	Value   any    `json:"value,omitempty"`
-}

models/query.go

@@ -1,6 +0,0 @@
-package models
-
-type Query struct {
-	Depth  int    `json:"depth,omitempty"`
-	RegExp string `json:"regExp,omitempty"`
-}

models/rights.go

@@ -1,18 +0,0 @@
-package models
-
-type Rights string
-
-const (
-	Read      Rights = "R"
-	Write     Rights = "W"
-	ReadWrite Rights = "RW"
-)
-
-func (r *Rights) GetRights() Rights {
-	if r == nil {
-		return ReadWrite
-	} else if *r == "" {
-		return ReadWrite
-	}
-	return *r
-}

models/set.go

@@ -1,8 +0,0 @@
-package models
-
-type Set struct {
-	Path   string  `json:"path"`
-	Driver *Driver `json:"driver,omitempty"`
-	Value  any     `json:"value,omitempty"`
-	Create bool    `json:"create,omitempty"`
-}

models/subscribe.go

@@ -1,10 +0,0 @@
-package models
-
-type Subscribe struct {
-	Path     string  `json:"path"`
-	Depth    int     `json:"depth"`
-	Driver   *string `json:"driver,omitempty"`
-	OnCreate bool    `json:"onCreate"`
-	OnDelete bool    `json:"onDelete"`
-	OnChange bool    `json:"onChange"`
-}

models/subscribtion.go

@@ -1,13 +1,13 @@
 package models
 
-type Subscribtions map[string]*Subscribtion
+type Subscriptions map[string]*Subscription
 
-type Subscribtion struct {
+type Subscription struct {
 	OnCreate bool
 	OnDelete bool
 	OnChange bool
 }
 
-func InitSubscribtion() Subscribtions {
+func InitSubscribtion() Subscriptions {
-	return make(Subscribtions)
+	return make(Subscriptions)
 }

models/type.go

@@ -1,67 +0,0 @@
-package models
-
-import (
-	"fmt"
-
-	"github.com/zuadi/tecamino-dbm/utils"
-)
-
-const (
-	NONE Type = "NONE"
-	BIT  Type = "BIT"
-	BYU  Type = "BYU"    // UINT8
-	BYS  Type = "BYS"    // INT8
-	WOS  Type = "WOS"    // INT16
-	WOU  Type = "WOU"    // UINT16
-	DWS  Type = "DWS"    // INT32
-	DWU  Type = "DWU"    // UINT32
-	LOS  Type = "LOS"    // INT64
-	LOU  Type = "LOU"    // UINT64
-	F32  Type = "F32"    // FLOAT32
-	F64  Type = "F64"    // FLOAT64
-	STR  Type = "STRING" // STRING
-)
-
-type Type string
-
-func (t *Type) DefaultValue(v any) any {
-	switch *t {
-	case BIT:
-		return false
-	case BYS, BYU, WOS, WOU, DWS, DWU, LOS, LOU, F32, F64:
-		return 0
-	case STR:
-		return ""
-	}
-	return nil
-}
-
-func (t *Type) ConvertValue(v any) any {
-	switch *t {
-	case BIT:
-		return utils.BoolFrom(v)
-	case BYS:
-		return utils.Int8From(v)
-	case BYU:
-		return utils.Uint8From(v)
-	case WOS:
-		return utils.Int16From(v)
-	case WOU:
-		return utils.Uint16From(v)
-	case DWS:
-		return utils.Int32From(v)
-	case DWU:
-		return utils.Uint32From(v)
-	case LOS:
-		return utils.Int64From(v)
-	case LOU:
-		return utils.Uint64From(v)
-	case F32:
-		return utils.Float32From(v)
-	case F64:
-		return utils.Float64From(v)
-	case STR:
-		return fmt.Sprintf("%v", v)
-	}
-	return nil
-}

server/jsonRequest.go

@@ -1,27 +0,0 @@
-package server
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func (s *Server) JsonRequest(c *gin.Context) {
-	var payload models.JsonData
-
-	if err := c.BindJSON(&payload); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if payload.Set != nil {
-
-	}
-
-	c.JSON(200, gin.H{
-		"name": payload,
-	})
-	return
-
-}

server/models/clients.go

@@ -3,7 +3,6 @@ package models
 import (
 	"context"
 	"fmt"
-	"net/http"
 
 	"github.com/coder/websocket"
 	"github.com/gin-gonic/gin"
@@ -14,7 +13,9 @@ var Origins []string = []string{"*"}
 type Clients map[string]*Client
 
 type Client struct {
-	Connected *bool           `json:"connected"`
+	Ctx       context.Context    `json:"-"`
+	Cancel    context.CancelFunc `json:"-"`
+	Connected bool               `json:"connected"`
 	Conn      *websocket.Conn    `json:"-"`
 }
 
@@ -23,60 +24,35 @@ func NewClients() Clients {
 }
 
 // Connect a recieving websocket connection
-func (c *Clients) ConnectRecievingWsConnection(id string, ctx *gin.Context) error {
+func (cl *Clients) ConnectRecievingWsConnection(id string, c *gin.Context) error {
-	if _, exists := (*c)[id]; exists {
+	if _, exists := (*cl)[id]; exists {
 		return nil
 	}
 
-	conn, err := websocket.Accept(ctx.Writer, ctx.Request, &websocket.AcceptOptions{
+	conn, err := websocket.Accept(c.Writer, c.Request, &websocket.AcceptOptions{
 		OriginPatterns: Origins,
 	})
 
 	if err != nil {
 		return fmt.Errorf("error accept websocket client: %s", err)
 	}
+	ctx, cancel := context.WithCancel(context.Background())
 
-	b := true
+	(*cl)[id] = &Client{
-	(*c)[id] = &Client{
+		Connected: true,
-		Connected: &b,
+		Ctx:       ctx,
+		Cancel:    cancel,
 		Conn:      conn,
 	}
 	return nil
 }
 
-// Connect a recieving websocket connection
-func (c *Clients) ConnectSendingWsConnection(id, url string) (*websocket.Conn, error) {
-	if _, exists := (*c)[id]; exists {
-		return (*c)[id].Conn, nil
-	}
-
-	header := http.Header{}
-	header.Set("Authorization", "Bearer "+id)
-
-	conn, _, err := websocket.Dial(context.Background(), url, &websocket.DialOptions{
-		HTTPHeader: header,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	b := true
-	(*c)[id] = &Client{
-		Connected: &b,
-		Conn:      conn,
-	}
-	return conn, nil
-}
-
 func (c *Clients) RemoveClient(id string) {
 	delete(*c, id)
 }
 
-func (c *Clients) GetClientPointer(id string) *bool {
-	return (*c)[id].Connected
-}
-
 func (c *Clients) DisconnectWsConnection(id string, code websocket.StatusCode, reason string) {
-	*(*c)[id].Connected = false
+	(*c)[id].Connected = false
 	(*c)[id].Conn.Close(code, reason)
+	(*c)[id].Cancel()
 }

server/models/connections.go

@@ -0,0 +1,67 @@
+package models
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+	"github.com/gin-gonic/gin"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+// serves as connection handler of websocket
+type Connections struct {
+	sync.RWMutex
+	Clients Clients
+}
+
+// initaiates new conections with client map
+func NewConnections() *Connections {
+	return &Connections{
+		Clients: NewClients(),
+	}
+}
+
+// Connect a recieving websocket connection
+func (c *Connections) ConnectRecievingWsConnection(id string, ctx *gin.Context) error {
+	return c.Clients.ConnectRecievingWsConnection(id, ctx)
+}
+
+func (c *Connections) RemoveClient(id string) {
+	c.Clients.RemoveClient(id)
+}
+
+func (c *Connections) DisconnectWsConnection(id string, code websocket.StatusCode, reason string) {
+	c.Clients.DisconnectWsConnection(id, code, reason)
+}
+
+// sends json response to client
+func (c *Connections) SendResponse(id string, r *json_dataModels.Response) error {
+	client, ok := c.Clients[id]
+	if !ok {
+		return fmt.Errorf("client not found for id %s", id)
+
+	}
+	b, err := json.Marshal(r)
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	w, err := client.Conn.Writer(ctx, websocket.MessageText)
+	if err != nil {
+		return err
+	}
+	defer w.Close()
+
+	_, err = w.Write(b)
+	if err != nil {
+		return err
+	}
+	return nil
+}

server/server.go

@@ -5,26 +5,34 @@ import (
 	"sync"
 
 	"github.com/gin-gonic/gin"
+	"github.com/tecamino/tecamino-dbm/cert"
 	"github.com/tecamino/tecamino-logger/logging"
-	"github.com/zuadi/tecamino-dbm/cert"
 )
 
+// server model for database manager websocket
 type Server struct {
 	Routes *gin.Engine
 	sync.RWMutex
 	Logger *logging.Logger
 }
 
+// initalizes new dbm server
 func NewServer() *Server {
 	return &Server{
 		Routes: gin.Default(),
 	}
 }
 
+// serve dbm as http
 func (s *Server) ServeHttp(port uint) error {
 	return s.Routes.Run(fmt.Sprintf(":%d", port))
 }
 
+// serve dbm as http
 func (s *Server) ServeHttps(port uint, cert cert.Cert) error {
+	// generate self signed tls certificate
+	if err := cert.GenerateSelfSignedCert(); err != nil {
+		return err
+	}
 	return s.Routes.RunTLS(fmt.Sprintf(":%d", port), cert.CertFile, cert.KeyFile)
 }

test/dbm_test.go

@@ -7,12 +7,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/zuadi/tecamino-dbm/args"
+	"github.com/tecamino/tecamino-dbm/args"
-	"github.com/zuadi/tecamino-dbm/cert"
+	"github.com/tecamino/tecamino-dbm/cert"
-	"github.com/zuadi/tecamino-dbm/dbm"
+	"github.com/tecamino/tecamino-dbm/dbm"
-	"github.com/zuadi/tecamino-dbm/models"
+	"github.com/tecamino/tecamino-dbm/models"
-	"github.com/zuadi/tecamino-dbm/server"
+	"github.com/tecamino/tecamino-dbm/server"
-	"github.com/zuadi/tecamino-dbm/utils"
+	"github.com/tecamino/tecamino-dbm/utils"
 )
 
 func TestCreateDps(t *testing.T) {
@@ -27,7 +27,7 @@ func TestCreateDps(t *testing.T) {
 			KeyFile:      "./cert/key.pem",
 		},
 		RootDir: ".",
-		DMAFile: "Test",
+		DBMFile: "Test",
 		Debug:   false,
 	})
 	if err != nil {
@@ -39,18 +39,18 @@ func TestCreateDps(t *testing.T) {
 	ndps := utils.ListofA2ZZ()
 	l := len(ndps)
 	s := time.Now()
-	for _, dp := range ndps {
+	// for _, dp := range ndps {
-		for i := 0; i < 100; i++ {
+	// 	for i := 0; i < 100; i++ {
-			err = dmaHandler.ImportDatapoints(&models.Datapoint{
+	// 		err = dmaHandler.ImportDatapoints(&models.Datapoint{
-				Path:  fmt.Sprintf("Test:%s:%03d", dp, i),
+	// 			Path:  fmt.Sprintf("Test:%s:%03d", dp, i),
-				Type:  RandomType(),
+	// 			Type:  models.RandomType(),
-				Value: rand.Int31(),
+	// 			Value: rand.Int31(),
-			})
+	// 		})
-			if err != nil {
+	// 		if err != nil {
-				t.Fatal(err)
+	// 			t.Fatal(err)
-			}
+	// 		}
-		}
+	// 	}
-	}
+	// }
 	fmt.Printf("time used to create %d datapoints: %v\n", l*100, time.Since(s))
 
 	var m runtime.MemStats
@@ -80,7 +80,7 @@ func TestQuery(t *testing.T) {
 			KeyFile:      "./cert/key.pem",
 		},
 		RootDir: ".",
-		DMAFile: "Test",
+		DBMFile: "Test",
 		Debug:   false,
 	})
 	if err != nil {
@@ -109,7 +109,7 @@ func TestUpdateDps(t *testing.T) {
 			KeyFile:      "./cert/key.pem",
 		},
 		RootDir: ".",
-		DMAFile: "Test",
+		DBMFile: "Test",
 		Debug:   false,
 	})
 	if err != nil {
@@ -121,17 +121,17 @@ func TestUpdateDps(t *testing.T) {
 	ndps := utils.ListofA2ZZ()
 	l := len(ndps)
 	s := time.Now()
-	for j, dp := range ndps {
+	// for j, dp := range ndps {
-		if j > 2 {
+	// 	if j > 2 {
-			break
+	// 		break
-		}
+	// 	}
-		for i := 0; i < 100; i++ {
+	// 	for i := 0; i < 100; i++ {
-			err = dmaHandler.UpdateDatapointValue(fmt.Sprintf("Test:%s:%03d", dp, i), rand.Int31())
+	// 		err = dmaHandler.UpdateDatapointValue(fmt.Sprintf("Test:%s:%03d", dp, i), rand.Int31())
-			if err != nil {
+	// 		if err != nil {
-				t.Fatal(err)
+	// 			t.Fatal(err)
-			}
+	// 		}
-		}
+	// 	}
-	}
+	// }
 	fmt.Printf("time used to update %d datapoints: %v\n", l*100, time.Since(s))
 
 	time.Sleep(5 * time.Second)

test/helper.go

@@ -1,41 +0,0 @@
-package test
-
-import (
-	"math/rand"
-
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func RandomType() models.Type {
-	n := rand.Intn(11) + 1
-
-	switch n {
-	case 1:
-		return "BIT"
-	case 2:
-		return "BYU"
-	case 3:
-		return "BYS"
-	case 4:
-		return "WOS"
-	case 5:
-		return "WOU"
-	case 6:
-		return "DWS"
-	case 7:
-		return "DWU"
-	case 8:
-		return "LOS"
-	case 9:
-		return "LOU"
-	case 10:
-		return "F32"
-	case 11:
-		return "F64"
-	case 12:
-		return "STRING"
-	default:
-		return "NONE"
-	}
-
-}

utils/convert.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 )
 
+// return any input type to float32
 func Float32From(v any) float32 {
 	switch val := v.(type) {
 	case bool:
@@ -44,6 +45,7 @@ func Float32From(v any) float32 {
 	}
 }
 
+// return any input type to float64
 func Float64From(v any) float64 {
 	switch val := v.(type) {
 	case bool:
@@ -83,6 +85,7 @@ func Float64From(v any) float64 {
 	}
 }
 
+// return any input type to int8
 func Int8From(v any) int8 {
 	switch val := v.(type) {
 	case bool:
@@ -122,6 +125,7 @@ func Int8From(v any) int8 {
 	}
 }
 
+// return any input type to int16
 func Int16From(v any) int16 {
 	switch val := v.(type) {
 	case bool:
@@ -161,6 +165,7 @@ func Int16From(v any) int16 {
 	}
 }
 
+// return any input type to int32
 func Int32From(v any) int32 {
 	switch val := v.(type) {
 	case bool:
@@ -200,6 +205,7 @@ func Int32From(v any) int32 {
 	}
 }
 
+// return any input type to int64
 func Int64From(v any) int64 {
 	switch val := v.(type) {
 	case bool:
@@ -239,6 +245,7 @@ func Int64From(v any) int64 {
 	}
 }
 
+// return any input type to int
 func Uint8From(v any) uint8 {
 	switch val := v.(type) {
 	case bool:
@@ -278,6 +285,7 @@ func Uint8From(v any) uint8 {
 	}
 }
 
+// return any input type to uint16
 func Uint16From(v any) uint16 {
 	switch val := v.(type) {
 	case bool:
@@ -317,6 +325,7 @@ func Uint16From(v any) uint16 {
 	}
 }
 
+// return any input type to uint32
 func Uint32From(v any) uint32 {
 	switch val := v.(type) {
 	case bool:
@@ -356,6 +365,7 @@ func Uint32From(v any) uint32 {
 	}
 }
 
+// return any input type to uint64
 func Uint64From(v any) uint64 {
 	switch val := v.(type) {
 	case bool:
@@ -395,6 +405,7 @@ func Uint64From(v any) uint64 {
 	}
 }
 
+// return any input type to bool
 func BoolFrom(v any) bool {
 	switch val := v.(type) {
 	case bool: