make new model for stringSlices allowOrigin helper

args/args.go

@@ -2,7 +2,6 @@ package args
 
 import (
 	"flag"
-	"strings"
 
 	"github.com/tecamino/tecamino-dbm/cert"
 	"github.com/tecamino/tecamino-dbm/models"
@@ -19,21 +18,10 @@ type Args struct {
 	Debug        bool
 }
 
-type StringSlice []string
-
-func (s *StringSlice) String() string {
-	return strings.Join(*s, ",")
-}
-
-func (s *StringSlice) Set(value string) error {
-	*s = append(*s, value)
-	return nil
-}
-
 // initialte cli arguments
 func Init() *Args {
 
-	var allowOrigins StringSlice
+	var allowOrigins models.StringSlice
 
 	flag.Var(&allowOrigins, "allowOrigin", "Allowed origin (can repeat this flag)")
 
@@ -43,6 +31,7 @@ func Init() *Args {
 	keyFile := flag.String("keyFile", "./cert/key.pem", "path of keyfile")
 	portHttp := flag.Uint("http-port", 8100, "json server communication for http/ws")
 	portHttps := flag.Uint("https-port", 8101, "json server communication for http/wss")
+	remotePort := flag.Uint("remotePort", 9500, "remote Port of gui user interface")
 	rootDir := flag.String("workingDir", "./", "working directory")
 	dbmFile := flag.String("dbm", "/test/test", "dbm file name")
 	debug := flag.Bool("debug", false, "debug flag")
@@ -58,6 +47,7 @@ func Init() *Args {
 		Port: models.Port{
 			Http:   *portHttp,
 			Https:  *portHttps,
+			Remote: *remotePort,
 		},
 		RootDir: *rootDir,
 		DBMFile: *dbmFile,
@@ -65,7 +55,7 @@ func Init() *Args {
 	}
 
 	if len(allowOrigins) == 0 {
-		allowOrigins = StringSlice{"http://localhost:9500"}
+		allowOrigins = models.StringSlice{"http://localhost:9500"}
 	}
 
 	a.AllowOrigins = allowOrigins

dbm/json_data.go

@@ -35,6 +35,7 @@ func (d *DBMHandler) Json_Data(c *gin.Context) {
 					Path:     res.Path,
 					Type:     res.Type,
 					Value:    res.Value,
+					Drivers:  &res.Drivers,
 					HasChild: res.Datapoints != nil,
 					Rights:   res.ReadWrite,
 				})

dbm/set.go

@@ -20,6 +20,7 @@ func (d *DBMHandler) Set(req *json_dataModels.Request, id string) {
 
 	for _, set := range req.Set {
 		dps := d.DBM.QueryDatapoints(1, set.Uuid, set.Path)
+
 		if len(dps) == 0 {
 			resp.SetError()
 			if resp.Message == "" {
@@ -27,8 +28,10 @@ func (d *DBMHandler) Set(req *json_dataModels.Request, id string) {
 			}
 			continue
 		}
+
 		for _, dp := range dps {
 			dp.UpdateValue(d.Conns, set.Value)
+
 			resp.AddSet(json_dataModels.Set{
 				Uuid:  dp.Uuid,
 				Path:  dp.Path,
@@ -36,6 +39,7 @@ func (d *DBMHandler) Set(req *json_dataModels.Request, id string) {
 			})
 		}
 	}
+
 	if err := d.Conns.SendResponse(id, resp); err != nil {
 		d.Log.Error("get.Set", err.Error())
 	}

dbm/subscribe.go

@@ -54,7 +54,6 @@ func (d *DBMHandler) Subscribe(req *json_dataModels.Request, id string) {
 			})
 		}
 	}
-
 	if err := d.Conns.SendResponse(id, resp); err != nil {
 		d.Log.Error("subscribe.Subscribe", err.Error())
 	}

dbm/webSocket.go

@@ -33,12 +33,15 @@ func (d *DBMHandler) WebSocket(c *gin.Context) {
 		if err != nil {
 			d.Log.Error("dbmHandler.webSocket.Websocket", "read json: "+err.Error())
 		}
+
 		// Sets
 		d.Get(request, id)
 		// Sets
 		d.Set(request, id)
+
 		// Subscribe
 		d.Subscribe(request, id)
+
 		// Unsubscribe
 		d.Unsubscribe(request, id)
 	}

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.3
-	github.com/tecamino/tecamino-json_data v0.0.16
+	github.com/tecamino/tecamino-json_data v0.0.17
 	github.com/tecamino/tecamino-logger v0.2.0
 )
 

go.sum

@@ -71,8 +71,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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tecamino/tecamino-json_data v0.0.16 h1:aZFxnhm4g6WMDPoqy4HosUk7vl0DB0iIcVs8bbT4MzU=
-github.com/tecamino/tecamino-json_data v0.0.16/go.mod h1:LLlyD7Wwqplb2BP4PeO86EokEcTRidlW5MwgPd1T2JY=
+github.com/tecamino/tecamino-json_data v0.0.17 h1:M12UzKbfIgu/q3ERsEhGNDV3DYOvc0TioU288kQjDCA=
+github.com/tecamino/tecamino-json_data v0.0.17/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

@@ -23,7 +23,7 @@ func main() {
 
 	//initialize new server
 	dbmHandler.Log.Debug("main", "initialize new server instance")
-	s := ws.NewServer(a.AllowOrigins)
+	s := ws.NewServer(a.AllowOrigins, a.Port.Remote)
 
 	//set routes
 	dbmHandler.Log.Debug("main", "setting routes")

models/datapoint.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"regexp"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/google/uuid"
@@ -34,7 +33,6 @@ type Datapoint struct {
 	ReadWrite      json_dataModels.Rights  `json:"readWrite"`
 	Drivers        json_dataModels.Drivers `json:"drivers,omitempty"`
 	Subscriptions  Subscriptions           `json:"-"`
-	sync.RWMutex   `json:"-"`
 }
 
 func (d *Datapoint) Set(path string, set json_dataModels.Set) (bool, error) {
@@ -381,25 +379,22 @@ func (d *Datapoint) RemoveSubscribtion(client *wsModels.Client) {
 }
 
 func (d *Datapoint) Publish(eventType string) error {
-	d.RLock()
-	defer d.RUnlock()
-
 	for client := range d.Subscriptions {
 		r := json_data.NewResponse()
 		r.AddPublish(json_dataModels.Publish{
 			Event: eventType,
 			Uuid:  d.Uuid,
 			Path:  d.Path,
+			Type:  d.Type,
 			Value: d.Value,
 		})
+
 		b, err := json.Marshal(r)
 		if err != nil {
 			return err
 		}
-		if err := client.SendResponse(b, 5); err != nil {
-			return err
-		}
 
+		client.SendResponse(b)
 	}
 	return nil
 }

models/port.go

@@ -3,4 +3,5 @@ package models
 type Port struct {
 	Http   uint
 	Https  uint
+	Remote uint
 }

models/stringSlices.go

@@ -0,0 +1,14 @@
+package models
+
+import "strings"
+
+type StringSlice []string
+
+func (s *StringSlice) String() string {
+	return strings.Join(*s, ",")
+}
+
+func (s *StringSlice) Set(value string) error {
+	*s = append(*s, value)
+	return nil
+}

test/dbm_test.go

@@ -142,7 +142,7 @@ func TestUpdateDps(t *testing.T) {
 
 func TestServer(t *testing.T) {
 	fmt.Println("start")
-	server := ws.NewServer([]string{".*"})
+	server := ws.NewServer([]string{".*"}, 9500)
 
 	t.Fatal(server.ServeHttp("http://localhost", 8100))
 }

utils/utils.go

@@ -1,5 +1,10 @@
 package utils
 
+import (
+	"fmt"
+	"net"
+)
+
 func ListofA2ZZ() (list []string) {
 	for i := 'A'; i <= 'Z'; i++ {
 		list = append(list, string(i))
@@ -9,12 +14,21 @@ func ListofA2ZZ() (list []string) {
 			list = append(list, string(i)+string(j))
 		}
 	}
-	// for i := 'A'; i <= 'Z'; i++ {
-	// 	for j := 'A'; j <= 'Z'; j++ {
-	// 		for k := 'A'; k <= 'Z'; k++ {
-	// 			list = append(list, string(i)+string(j)+string(k))
-	// 		}
-	// 	}
-	// }
 	return
 }
+
+func GetLocalIP() (string, error) {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return "", err
+	}
+
+	for _, addr := range addrs {
+		if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
+			if ipNet.IP.To4() != nil {
+				return ipNet.IP.String(), nil
+			}
+		}
+	}
+	return "", fmt.Errorf("no local IP address found")
+}

websocket/clientHandler.go

@@ -60,14 +60,12 @@ func (c *ClientHandler) SendResponse(id string, r *json_dataModels.Response) err
 		return fmt.Errorf("client not found for id %s", id)
 
 	}
-	b, err := json.Marshal(r)
+
+	b, err := json.Marshal(*r)
 	if err != nil {
 		return err
 	}
-
-	if err := client.SendResponse(b, 5); err != nil {
-		return err
-	}
+	client.SendResponse(b)
 
 	return nil
 }

websocket/models/client.go

@@ -13,17 +13,30 @@ import (
 
 var Origins []string = []string{"*"}
 
+const (
+	// Time allowed to write a message to the peer.
+	writeWait = 10 * time.Second
+
+	// Time allowed to read the next pong message from the peer.
+	pongWait = 10 * time.Second
+
+	// Send pings to peer with this period. Must be less than pongWait.
+	pingPeriod = (pongWait * 9) / 10
+)
+
 type Client struct {
 	Id         string
 	Connected  bool            `json:"connected"`
-	Conn      *websocket.Conn `json:"-"`
+	conn       *websocket.Conn `json:"-"`
 	OnOpen     func()
 	OnMessage  func(data []byte)
 	OnClose    func(code int, reason string)
 	OnError    func(err error)
 	OnPing     func()
 	OnPong     func()
-	timeout   time.Duration
+	sendPong   chan string
+	send       chan []byte
+	unregister chan []byte
 }
 
 var upgrader = websocket.Upgrader{
@@ -54,75 +67,132 @@ func ConnectNewClient(id string, c *gin.Context) (*Client, error) {
 	client := &Client{
 		Id:         id,
 		Connected:  true,
-		Conn:      conn,
-		timeout:   5,
+		conn:       conn,
+		sendPong:   make(chan string),
+		send:       make(chan []byte),
+		unregister: make(chan []byte),
 	}
 
 	conn.SetPingHandler(func(appData string) error {
 		if client.OnPing != nil {
 			client.OnPing()
 		}
-		conn.SetWriteDeadline(time.Now().Add(client.timeout))
-		conn.SetReadDeadline(time.Now().Add(client.timeout))
-		return conn.WriteMessage(websocket.PongMessage, []byte(appData))
+		conn.SetWriteDeadline(time.Now().Add(writeWait))
+		conn.SetReadDeadline(time.Now().Add(writeWait))
+		client.sendPong <- appData
+		return nil
 	})
 
-	conn.SetPongHandler(func(appData string) error {
+	conn.SetPongHandler(func(string) error {
+		conn.SetReadDeadline(time.Now().Add(pongWait))
 		if client.OnPong != nil {
 			client.OnPong()
 		}
-		conn.SetReadDeadline(time.Now().Add(client.timeout))
 		return nil
 	})
 
 	// Start reading messages from client
-	go client.Listen(7)
+	go client.Read()
+	go client.Write()
 	return client, nil
 }
 
-func (c *Client) Listen(timeout uint) {
-	if timeout > 0 {
-		c.timeout = time.Duration(timeout) * time.Second
-	}
-
+func (c *Client) Read() {
 	if c.OnOpen != nil {
 		c.OnOpen()
 	}
 
-	c.Conn.SetReadDeadline(time.Now().Add(c.timeout))
+	c.conn.SetReadDeadline(time.Now().Add(writeWait))
 	for c.Connected {
-		msgType, msg, err := c.Conn.ReadMessage()
+		msgType, msg, err := c.conn.ReadMessage()
 		if err != nil {
 			c.handleError(fmt.Errorf("read error (id:%s): %w", c.Id, err))
 			return
 		}
 		switch msgType {
 		case websocket.CloseMessage:
-			c.handleClose(1000, "Client closed")
+			c.Close(websocket.CloseNormalClosure, "Client closed")
 			return
 		case websocket.TextMessage:
-			if isPing := c.handleJsonPing(msg); isPing {
-				continue
-			}
+			if isPing := c.handleJsonPing(msg); !isPing {
 				if c.OnMessage != nil {
 					c.OnMessage(msg)
 				} else {
 					log.Printf("Received message but no handler set (id:%s): %s", c.Id, string(msg))
 				}
+			}
 		default:
 			log.Printf("Unhandled message type %d (id:%s)", msgType, c.Id)
 		}
 	}
 }
 
+func (c *Client) Write() {
+	ticker := time.NewTicker(pingPeriod)
+	defer func() {
+		ticker.Stop()
+		c.conn.Close()
+	}()
+	for {
+
+		select {
+		case message, ok := <-c.send:
+			c.conn.SetWriteDeadline(time.Now().Add(writeWait))
+			if !ok {
+				// The hub closed the channel.
+				if err := c.conn.WriteMessage(websocket.CloseMessage, []byte{}); err != nil {
+					c.handleError(err)
+					return
+				}
+				c.handleError(fmt.Errorf("server %s closed channel", c.Id))
+				return
+			} else {
+				if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
+					c.handleError(err)
+					return
+				}
+			}
+		case <-ticker.C:
+			c.conn.SetWriteDeadline(time.Now().Add(writeWait))
+			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+				c.handleError(err)
+				return
+			}
+
+			if c.OnPing != nil {
+				c.OnPing()
+			}
+
+		case message, ok := <-c.sendPong:
+			if ok {
+				c.conn.WriteMessage(websocket.PongMessage, []byte(message))
+			}
+		case message := <-c.unregister:
+			c.conn.WriteMessage(websocket.CloseMessage, message)
+			c.Connected = false
+			close(c.sendPong)
+			close(c.send)
+			close(c.unregister)
+			return
+		}
+
+	}
+}
+
 func (c *Client) handleJsonPing(msg []byte) (isPing bool) {
 	var wsMsg WSMessage
 	err := json.Unmarshal(msg, &wsMsg)
+
 	if err == nil && wsMsg.IsPing() {
-		c.Conn.SetReadDeadline(time.Now().Add(c.timeout))
+		c.conn.SetReadDeadline(time.Now().Add(writeWait))
 		// Respond with pong JSON
-		c.Conn.SetWriteDeadline(time.Now().Add(c.timeout))
-		err = c.Conn.WriteMessage(websocket.TextMessage, GetPongByteSlice())
+		select {
+		case c.send <- GetPongByteSlice():
+		default:
+			// optional: log or handle if send buffer is full
+			c.handleError(fmt.Errorf("failed to queue pong message"))
+			return
+		}
 		if err != nil {
 			c.handleError(fmt.Errorf("write pong error: %w", err))
 			return
@@ -132,33 +202,39 @@ func (c *Client) handleJsonPing(msg []byte) (isPing bool) {
 		}
 		isPing = true
 	}
+
 	return
 }
 
-func (c *Client) SendResponse(data []byte, timeout uint) error {
-	c.Conn.SetWriteDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
-	return c.Conn.WriteMessage(websocket.TextMessage, data)
-}
-
-func (c *Client) Close(code int, reason string) {
-	c.handleClose(code, reason)
-}
-
-func (c *Client) handleClose(code int, text string) {
+func (c *Client) SendResponse(data []byte) {
 	if !c.Connected {
 		return
 	}
-	c.Connected = false
-	if c.OnClose != nil {
-		c.OnClose(code, text)
+	c.send <- data
 }
-	c.Conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(code, text))
-	c.Conn.Close()
+
+func (c *Client) Close(code int, reason string) error {
+	closeMsg := websocket.FormatCloseMessage(code, reason)
+	select {
+	case c.unregister <- closeMsg: // Attempt to send
+	default: // If the channel is full, this runs
+		return fmt.Errorf("attempt close client socket failed")
+	}
+	if c.OnClose != nil {
+		c.OnClose(code, reason)
+	}
+	return nil
 }
 
 func (c *Client) handleError(err error) {
 	if c.OnError != nil {
 		c.OnError(err)
 	}
-	c.Close(websocket.CloseInternalServerErr, err.Error())
+	if err := c.Close(websocket.CloseInternalServerErr, err.Error()); err != nil {
+		if c.OnError != nil {
+			c.OnError(err)
+		} else {
+			fmt.Println("error: ", err)
+		}
+	}
 }

websocket/server.go

@@ -2,12 +2,14 @@ package websocket
 
 import (
 	"fmt"
+	"log"
 	"sync"
 	"time"
 
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
 	"github.com/tecamino/tecamino-dbm/cert"
+	"github.com/tecamino/tecamino-dbm/utils"
 	"github.com/tecamino/tecamino-logger/logging"
 )
 
@@ -19,8 +21,17 @@ type Server struct {
 }
 
 // initalizes new dbm server
-func NewServer(allowOrigins []string) *Server {
+func NewServer(allowOrigins []string, port uint) *Server {
 	r := gin.Default()
+
+	allowOrigins = append(allowOrigins, fmt.Sprintf("http://localhost:%d", port))
+
+	localIP, err := utils.GetLocalIP()
+	if err != nil {
+		log.Printf("get local ip : %s", err.Error())
+	} else {
+		allowOrigins = append(allowOrigins, fmt.Sprintf("http://%s:%d", localIP, port))
+	}
 	r.Use(cors.New(cors.Config{
 		AllowOrigins:     allowOrigins,
 		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},