add resubscribe (in progress)

fix crash when no bus found in map

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
+}

cfg/cfg.go

@@ -1,7 +1,6 @@
 package cfg
 
 import (
-	"fmt"
 	"os"
 	"path"
 
@@ -51,7 +50,7 @@ func (c *Cfg) SaveCfg(data any) error {
 func (c *Cfg) LoadCfg(data any) error {
 	p := path.Join(c.Dir, c.Name) + ".cfg"
 	if _, err := os.Stat(p); err != nil {
-		return fmt.Errorf("no configuration file: '%s' found", p)
+		return nil
 	}
 
 	b, err := os.ReadFile(p)

client/client.go

@@ -0,0 +1,71 @@
+package client
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/coder/websocket"
+	"github.com/coder/websocket/wsjson"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+	"github.com/tecamino/tecamino-logger/logging"
+)
+
+type Client struct {
+	conn   *websocket.Conn
+	ctx    context.Context
+	cancel context.CancelFunc
+	log    *logging.Logger
+}
+
+// Initialize new websocket server
+func NewClient(log *logging.Logger) *Client {
+	c := Client{
+		log: log,
+	}
+	c.ctx, c.cancel = context.WithCancel(context.Background())
+	return &c
+}
+
+// Connect to websocket server
+// ip: ip address of server
+func (c *Client) Connect(ip, id string, port uint) (err error) {
+	c.conn, _, err = websocket.Dial(c.ctx, fmt.Sprintf("ws://%s:%d/ws?id=%s", ip, port, id), nil)
+	return
+}
+
+// Close connection to websocket server
+func (c *Client) Disconnect() {
+	c.cancel()
+}
+
+// Subscribe to websocket server
+func (c *Client) Subscribe(id string) error {
+
+	req := json_data.NewRequest()
+	req.AddDriverSubscription(".*", id, 0, true, false, false)
+	if err := wsjson.Write(c.ctx, c.conn, req); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Client) ReadJsonData() (response json_dataModels.Response, err error) {
+
+	err = wsjson.Read(c.ctx, c.conn, &response)
+	if err != nil {
+		code := websocket.CloseStatus(err)
+
+		switch code {
+		case websocket.StatusNormalClosure,
+			websocket.StatusGoingAway,
+			websocket.StatusNoStatusRcvd:
+			c.log.Info("webSocket.readJsonData", fmt.Sprintf("WebSocket closed: %v (code: %v)\n", err, code))
+			return
+		default:
+			c.log.Error("webSocket.readJsonData", fmt.Sprintf("WebSocket read error: %v (code: %v)\n", err, code))
+			return
+		}
+	}
+	return
+}

driver/artNet.go

@@ -2,19 +2,21 @@ package driver
 
 import (
 	"artNet/cfg"
+	"artNet/client"
 	"artNet/models"
-	serverModels "artNet/server/models"
 	"fmt"
+	"path"
 
 	"github.com/tecamino/tecamino-logger/logging"
 )
 
 type ArtNetDriver struct {
-	Name        string                 `yaml:"driver" json:"driver"`
+	Name          string                 `yaml:"driver" json:"driver"`
-	Buses       map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
+	Buses         map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
-	cfgHandler  *cfg.Cfg               `yaml:"-" json:"-"`
+	cfgHandler    *cfg.Cfg               `yaml:"-" json:"-"`
-	Connections serverModels.Clients   `yaml:"-"`
+	Conn          *client.Client         `yaml:"-" json:"-"`
-	Log         *logging.Logger        `yaml:"-"`
+	Subscriptions models.Subscriptions   `yaml:"-" json:"-"`
+	Log           *logging.Logger        `yaml:"-" json:"-"`
 }
 
 // initialize new Art-Net driver
@@ -25,25 +27,29 @@ func NewDriver(cfgDir, name string, debug bool) (*ArtNetDriver, error) {
 		cfgDir = "./cfg"
 	}
 
-	logger, err := logging.NewLogger(name, debug)
+	logger, err := logging.NewLogger(path.Join(cfgDir, name+".log"), &logging.Config{
+		MaxSize:     1,
+		MaxBackup:   3,
+		MaxAge:      28,
+		Debug:       debug,
+		TerminalOut: true,
+	})
 	if err != nil {
 		panic(err)
 	}
 
 	logger.Debug("artNet.NewDriver", "initialize "+name+" driver")
 	d := ArtNetDriver{
-		Name:        name,
+		Name:       name,
-		Buses:       make(map[string]*models.Bus),
+		Buses:      make(map[string]*models.Bus),
-		cfgHandler:  cfg.NewCfgHandler(cfgDir, name),
+		cfgHandler: cfg.NewCfgHandler(cfgDir, name),
-		Connections: serverModels.NewClients(),
+		Log:        logger,
-		Log:         logger,
 	}
 
 	if err := d.LoadCfg(); err != nil {
-		logger.Error("artNet.NewDriver", "error load driver configuration: "+err.Error())
+		logger.Error("artNet.NewDriver.LoadCfg", "error load driver configuration: "+err.Error())
 		return nil, err
 	}
-
 	return &d, nil
 }
 
@@ -54,8 +60,8 @@ func (d *ArtNetDriver) LoadCfg() error {
 		return err
 	}
 
-	for _, b := range d.Buses {
+	for name, b := range d.Buses {
-		d.NewBus(b.Name, b.Ip, *b.Port)
+		d.NewBus(name, b.Ip, *b.Port)
 	}
 	return nil
 }
@@ -67,11 +73,46 @@ func (d *ArtNetDriver) NewBus(name, ip string, port int) *models.Bus {
 	return b
 }
 
-func (d *ArtNetDriver) SetValue(set models.Set) error {
+func (d *ArtNetDriver) SetValue(bus string, address uint, value uint8) error {
-	if _, ok := d.Buses[set.Bus]; !ok {
+	if _, ok := d.Buses[bus]; !ok {
-		return fmt.Errorf("no bus '%s' found", set.Bus)
+		return fmt.Errorf("no bus '%s' found", bus)
+	}
+	if d.Buses[bus].Data == nil {
+		return fmt.Errorf("no dmx data on bus '%s' found", bus)
+	}
+	d.Buses[bus].Data.SetValue(address, value)
+	return d.Buses[bus].SendData()
+}
+
+// connect to websocket server and listen to subscriptions
+// ip: ip address of server
+// id: id of driver
+// port: port of server
+func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
+	d.Conn = client.NewClient(d.Log)
+	if err := d.Conn.Connect(ip, id, port); err != nil {
+		return err
+	}
+	defer d.Conn.Disconnect()
+
+	if err := d.Conn.Subscribe(id); err != nil {
+		return err
+	}
+
+	for {
+		respond, err := d.Conn.ReadJsonData()
+		if err != nil {
+			return err
+		}
+
+		d.Subscribe(respond.Subscribe...)
+
+		for _, pub := range respond.Publish {
+			if sub, ok := d.Subscriptions[pub.Uuid]; ok {
+				if err := d.SetValue(sub.Bus, sub.Address, uint8(pub.Value.(float64))); err != nil {
+					d.Log.Info("artNet.Connect", err.Error())
+				}
+			}
+		}
 	}
-	d.Buses[set.Bus].Data.SetValue(set.Address, set.Value)
-
-	return d.Buses[set.Bus].SendData()
 }

driver/bus.go

@@ -8,6 +8,8 @@ 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"
 )
 
 // sends a list of all buses in the driver
@@ -25,70 +27,170 @@ func (d *ArtNetDriver) GetAllBuses(c *gin.Context) {
 }
 
 func (d *ArtNetDriver) CreateBus(c *gin.Context) {
-	_, err := auth.GetIDFromAuth(c)
+	_, err := auth.GetIDFromQuery(c)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "id: " + err.Error()})
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage(err.Error())
+		c.JSON(http.StatusBadRequest, r)
 		return
 	}
 
-	var payload models.Bus
+	busPayload := models.Bus{}
-
+	if err := busPayload.ParsePayload(c); err != nil {
-	if err := c.BindJSON(&payload); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "json: " + err.Error()})
 		return
 	}
 
-	if payload.Name == "" {
+	if addr := net.ParseIP(busPayload.Ip); addr == nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "bus name missing"})
+		r := json_data.NewResponse()
-		return
+		r.SetError()
-	} else if addr := net.ParseIP(payload.Ip); addr == nil {
+		r.SetMessage("wrong ip '" + busPayload.Ip + "'")
-
+		c.JSON(http.StatusBadRequest, r)
-		c.JSON(http.StatusBadRequest, gin.H{"error": "wrong ip '" + payload.Ip + "'"})
 		return
 	}
 
-	if _, ok := d.Buses[payload.Name]; ok {
+	if _, ok := d.Buses[busPayload.Name]; ok {
-		c.JSON(http.StatusOK, gin.H{"message": "bus " + payload.Name + " exists already"})
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("bus " + busPayload.Name + " exists already")
+		c.JSON(http.StatusOK, r)
 		return
 	}
 
-	bus := d.NewBus(payload.Name, payload.Ip, payload.GetPort())
+	bus := d.NewBus(busPayload.Name, busPayload.Ip, busPayload.GetPort())
-	c.JSON(http.StatusOK, gin.H{
+
-		"message": fmt.Sprintf("bus '%s' successfully created with ip: %s and on port: %d", bus.Name, bus.Ip, bus.GetPort()),
+	r := json_data.NewResponse()
-	})
+	r.SetMessage(fmt.Sprintf("bus '%s' successfully created with ip: %s and on port: %d", bus.Name, bus.Ip, bus.GetPort()))
+	c.JSON(http.StatusOK, r)
 	d.cfgHandler.SaveCfg(*d)
 }
 
 func (d *ArtNetDriver) RemoveBus(c *gin.Context) {
-	_, err := auth.GetIDFromAuth(c)
+	_, err := auth.GetIDFromQuery(c)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "id: " + err.Error()})
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
 		return
 	}
 
-	var payload models.Bus
+	busPayload := models.Bus{}
-
+	if err := busPayload.ParsePayload(c); err != nil {
-	if err := c.BindJSON(&payload); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "json: " + err.Error()})
 		return
 	}
 
-	if payload.Name == "" {
+	if _, ok := d.Buses[busPayload.Name]; !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "bus name missing"})
+		r := json_dataModels.NewResponse()
-		return
+		r.SetMessage("bus " + busPayload.Name + " not found")
-	}
+		c.JSON(http.StatusBadRequest, r)
-
-	if _, ok := d.Buses[payload.Name]; !ok {
-		c.JSON(http.StatusOK, gin.H{"message": "bus " + payload.Name + " not found"})
-		c.JSON(http.StatusOK, models.JsonResponse{
-			Message: "bus " + payload.Name + " not found"})
 		return
 	} else {
-		delete(d.Buses, payload.Name)
+		delete(d.Buses, busPayload.Name)
 	}
-
+	r := json_dataModels.NewResponse()
-	c.JSON(http.StatusOK, models.JsonResponse{
+	r.SetMessage(fmt.Sprintf("bus '%s' successfully removed", busPayload.Name))
-		Message: fmt.Sprintf("bus '%s' successfully removed", payload.Name),
+	c.JSON(http.StatusOK, r)
-	})
 	d.cfgHandler.SaveCfg(*d)
 }
+
+func (d *ArtNetDriver) Start(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	d.Buses[busPayload.Name].Start(d.Log)
+
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' running", busPayload.Name))
+	c.JSON(http.StatusOK, r)
+}
+
+func (d *ArtNetDriver) Stop(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	d.Buses[busPayload.Name].Stop()
+
+	r := json_dataModels.NewResponse()
+	r.SetMessage(fmt.Sprintf("bus '%s' stopped", busPayload.Name))
+	c.JSON(http.StatusOK, r)
+}
+
+func (d *ArtNetDriver) Resubscribe(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	if _, ok := d.Buses[busPayload.Name]; !ok {
+		r := json_dataModels.NewResponse()
+		r.SetMessage("bus " + busPayload.Name + " not found")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	if busPayload.Resubscribe == nil {
+		r := json_dataModels.NewResponse()
+		r.SetMessage("no resubscriptions in request")
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	d.Subscribe(*busPayload.Resubscribe...)
+}
+
+func (d *ArtNetDriver) Status(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	busPayload := models.Bus{}
+	if err := busPayload.ParsePayload(c); err != nil {
+		return
+	}
+
+	r := json_dataModels.NewResponse()
+	state := "stopped"
+	if d.Buses[busPayload.Name].Status() {
+		state = "running"
+	}
+	r.SetMessage(fmt.Sprintf("bus '%s' %s", busPayload.Name, state))
+	c.JSON(http.StatusOK, r)
+}

driver/subscribe.go

@@ -0,0 +1,20 @@
+package driver
+
+import (
+	"artNet/models"
+
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *ArtNetDriver) Subscribe(subs ...json_dataModels.Subscription) {
+	if d.Subscriptions == nil {
+		d.Subscriptions = models.NewSubscriptions()
+	}
+
+	for _, sub := range subs {
+		if drv, ok := (*sub.Drivers)[sub.Driver]; ok {
+			d.Subscriptions.AddSubscription(sub.Uuid, drv)
+			d.SetValue(drv.Bus, drv.Address, uint8(sub.Value.(float64)))
+		}
+	}
+}

driver/webSocket.go

@@ -1,63 +0,0 @@
-package driver
-
-import (
-	"context"
-	"log"
-	"time"
-
-	"artNet/auth"
-	"artNet/models"
-
-	"github.com/coder/websocket"
-	"github.com/coder/websocket/wsjson"
-	"github.com/gin-gonic/gin"
-)
-
-const (
-	OnCreate = "onCreate"
-	OnChange = "onChange"
-	OnDelete = "onDelete"
-)
-
-func (d *ArtNetDriver) Websocket(c *gin.Context) {
-	id, err := auth.GetIDFromAuth(c)
-	if err != nil {
-		d.Log.Error("artNet.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
-		log.Println("error id:", err)
-		return
-	}
-	d.Log.Debug("artNet.webSocket.Websocket", "authorization id token: "+id)
-
-	ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Minute)
-	defer cancel()
-	conn, err := d.Connections.ConnectRecievingWsConnection(id, c)
-	if err != nil {
-		d.Log.Error("artNet.webSocket.Websocket", "error connecting recieving websocket conection: "+err.Error())
-		return
-	}
-	defer d.Connections.DisconnectRecievingWsConnection(id, websocket.StatusInternalError, "Internal error")
-
-	var request models.JsonData
-	//Read loop
-	for {
-
-		err := wsjson.Read(ctx, conn, &request)
-		if err != nil {
-			d.Log.Error("artNet.webSocket.Websocket", "read error:"+err.Error())
-			log.Println("WebSocket read error:", err)
-			break
-		}
-
-		// Set
-		if request.Set != nil {
-			for _, set := range *request.Set {
-				if err = d.SetValue(set); err != nil {
-					d.Log.Error("artNet.webSocket.Websocket", "set value error"+err.Error())
-					log.Println(err)
-					continue
-				}
-				time.Sleep(23 * time.Millisecond)
-			}
-		}
-	}
-}

go.mod

@@ -7,8 +7,11 @@ toolchain go1.23.8
 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/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e
-	github.com/tecamino/tecamino-logger v0.1.1
+	github.com/tecamino/tecamino-json_data v0.0.13
+	github.com/tecamino/tecamino-logger v0.2.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -39,5 +42,5 @@ require (
 	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/text v0.15.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.2.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=
@@ -63,8 +65,10 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e h1:nt2877sKfojlHCTOBXbpWjBkuWKritFaGIfgQwbQUls=
 github.com/tatsushid/go-fastping v0.0.0-20160109021039-d7bb493dee3e/go.mod h1:B4+Kq1u5FlULTjFSM707Q6e/cOHFv0z/6QRoxubDIQ8=
-github.com/tecamino/tecamino-logger v0.1.1 h1:bK0SEQpbjui42OsnM6JCDThaGMBoqwVj/Op6ESqDwV4=
+github.com/tecamino/tecamino-json_data v0.0.13 h1:hugbmCgXXh0F7YQAEbbJYHkSdq1caejD7SajDiMs42I=
-github.com/tecamino/tecamino-logger v0.1.1/go.mod h1:sGysmiFGIdr4vLJRAI+fJgsa7EoRRuxvRrKW7GnGQkw=
+github.com/tecamino/tecamino-json_data v0.0.13/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=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
@@ -94,6 +98,8 @@ google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFW
 google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -4,7 +4,9 @@ import (
 	"artNet/driver"
 	"artNet/server"
 	"flag"
+	"fmt"
 	"os"
+	"time"
 
 	"github.com/gin-gonic/gin"
 )
@@ -13,10 +15,13 @@ const DriverName string = "ArtNetDriver"
 
 func main() {
 	// cli flags
-	port := flag.Uint("port-http", 8110, "http server listening port")
 	cfgDir := flag.String("cfg", "./cfg", "config directory")
 	workingDir := flag.String("workingDirectory", ".", "current working directory")
+	serverIp := flag.String("serverIp", "127.0.0.1", "ip address of server")
+	serverPort := flag.Uint("serverPort", 8100, "port of server")
+	wsPort := flag.Uint("port", 8200, "websocket port")
 	debug := flag.Bool("debug", false, "debug logging")
+	start := flag.Bool("start", false, "starts all buses on startup")
 	flag.Parse()
 
 	//change working directory only if value is given
@@ -37,18 +42,38 @@ func main() {
 
 	//set routes
 	artNetDriver.Log.Debug("main", "setting routes")
-	s.Routes.GET("/ws", artNetDriver.Websocket)
 	s.Routes.GET("/buses/all", artNetDriver.GetAllBuses)
 	s.Routes.POST("/buses/create", artNetDriver.CreateBus)
 	s.Routes.POST("/buses/remove", artNetDriver.RemoveBus)
+	s.Routes.POST("/buses/start", artNetDriver.Start)
+	s.Routes.POST("/buses/status", artNetDriver.Status)
+	s.Routes.POST("/buses/stop", artNetDriver.Stop)
+	s.Routes.POST("/buses/resubscribe", artNetDriver.Resubscribe)
 
 	s.Routes.GET("/", func(c *gin.Context) {
 		c.String(200, "ArtNet Driver WebSocket Server is running!")
 	})
 
-	// start http server
+	go func() {
-	if err := s.ServeHttp(*port); err != nil {
+		if err := s.ServeHttp(*wsPort); err != nil {
-		artNetDriver.Log.Error("main", "error http server "+err.Error())
+			artNetDriver.Log.Error("main", err.Error())
-		panic(err)
+		}
+	}()
+
+	artNetDriver.Log.Info("main", fmt.Sprintf("connect to server  ws://%s:%d with id %s", *serverIp, *serverPort, DriverName))
+
+	if *start {
+		for busName, bus := range artNetDriver.Buses {
+			artNetDriver.Log.Info("main", fmt.Sprintf("starting bus %s", busName))
+			// start bus and listen to subscriptions
+			bus.Start(artNetDriver.Log)
+		}
 	}
+
+	// connect to server
+	for {
+		artNetDriver.Log.Error("main", artNetDriver.Connect(*serverIp, DriverName, *serverPort))
+		time.Sleep(10 * time.Second)
+	}
+
 }

models/bus.go

@@ -1,12 +1,18 @@
 package models
 
 import (
+	"context"
+	"errors"
 	"fmt"
-	"log"
 	"net"
+	"net/http"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/tatsushid/go-fastping"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+	"github.com/tecamino/tecamino-logger/logging"
 )
 
 // Art-Net constants
@@ -16,10 +22,13 @@ const (
 
 // Art-Net Interface
 type Bus struct {
-	Name string `yaml:"name" json:"name"`
+	Name        string                          `yaml:"name" json:"name"`
-	Ip   string `yaml:"ip" json:"ip"`
+	Ip          string                          `yaml:"ip" json:"ip"`
-	Port *int   `yaml:"port" json:"port,omitempty"`
+	Port        *int                            `yaml:"port" json:"port,omitempty"`
-	Data *DMX   `yaml:"-" json:"-"`
+	Data        *DMX                            `yaml:"-" json:"-"`
+	Resubscribe *[]json_dataModels.Subscription `yaml:"-" json:"resubscribe"`
+	Watchdog    context.CancelFunc              `yaml:"-" json:"-"`
+	Reachable   bool                            `yaml:"-" json:"-"`
 }
 
 // adds new Art-Net interface to driver port 0 = 6454 (default art-net)
@@ -92,8 +101,56 @@ func (b *Bus) Poll(interval time.Duration) error {
 	}
 }
 
-// start polling dmx data in milliseconds 0 = aprox. 44Hertz
+// start bus
+func (b *Bus) Start(log *logging.Logger) {
+	var ctx context.Context
+	ctx, b.Watchdog = context.WithCancel(context.Background())
+
+	go func() {
+		var interval time.Duration = 10 * time.Second
+		log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog stopped", b.Name, b.Ip))
+		for {
+			select {
+			case <-ctx.Done():
+				log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog stopped", b.Name, b.Ip))
+				b.Reachable = false
+				return
+			default:
+				b.Reachable = false
+				if reached, err := isUDPReachable(b.Ip); err != nil {
+					log.Error("bus.Start", err)
+					interval = 5 * time.Second
+				} else if !reached {
+					log.Error("bus.Start", fmt.Sprintf("device:%s ip:%s not reached", b.Name, b.Ip))
+					interval = 5 * time.Second
+				} else {
+					b.Reachable = true
+					log.Info("bus.Start", fmt.Sprintf("device:%s ip:%s watchdog running", b.Name, b.Ip))
+					interval = 30 * time.Second
+				}
+				time.Sleep(interval)
+			}
+		}
+	}()
+}
+
+// stop bus
+func (b *Bus) Stop() {
+	if b.Watchdog != nil {
+		b.Watchdog()
+	}
+}
+
+// status bus
+func (b *Bus) Status() bool {
+	return b.Watchdog != nil
+}
+
+// send dmx data
 func (b *Bus) SendData() error {
+	if !b.Reachable {
+		return nil
+	}
 	// Send packet over UDP
 	conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
 		IP:   net.ParseIP(b.Ip),
@@ -105,21 +162,31 @@ func (b *Bus) SendData() error {
 	}
 	defer conn.Close()
 
-	go func() {
-		if reached, err := isUDPReachable(b.Ip); err != nil {
-			log.Println(err)
-			return
-		} else if !reached {
-			log.Println("device not reachable")
-			return
-		}
-	}()
-
 	_, err = conn.Write(NewArtNetPackage(b.Data))
 
 	return err
 }
 
+func (b *Bus) ParsePayload(c *gin.Context) error {
+
+	if err := c.BindJSON(b); err != nil {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("json: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return err
+	}
+
+	if b.Name == "" {
+		r := json_data.NewResponse()
+		r.SetError()
+		r.SetMessage("bus name missing")
+		c.JSON(http.StatusBadRequest, r)
+		return errors.New("bus name missing")
+	}
+	return nil
+}
+
 func isUDPReachable(ip string) (recieved bool, err error) {
 	p := fastping.NewPinger()
 	ra, err := net.ResolveIPAddr("ip4:icmp", ip)

models/jsonData.go

@@ -1,23 +0,0 @@
-package models
-
-type JsonData struct {
-	Set    *[]Set `json:"set,omitempty"`
-	Create *[]Bus `json:"create,omitempty"`
-}
-
-func NewRequest() *JsonData {
-	return &JsonData{}
-
-}
-
-func (r *JsonData) AddSet(bus string, address uint, value uint8) {
-	if r.Set == nil {
-		r.Set = &[]Set{}
-	}
-
-	*r.Set = append(*r.Set, Set{
-		Bus:     bus,
-		Address: address,
-		Value:   value,
-	})
-}

models/jsonResponse.go

@@ -1,7 +0,0 @@
-package models
-
-type JsonResponse struct {
-	Error   bool   `json:"error,omitempty"`
-	Message string `json:"message,omitempty"`
-	Data    string `json:"data,omitempty"`
-}

models/subscriptions.go

@@ -0,0 +1,24 @@
+package models
+
+import (
+	"github.com/google/uuid"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+type Subscriptions map[uuid.UUID]Subscription
+
+type Subscription struct {
+	Bus     string
+	Address uint
+}
+
+func NewSubscriptions() Subscriptions {
+	return make(Subscriptions)
+}
+
+func (s *Subscriptions) AddSubscription(uid uuid.UUID, drv *json_dataModels.Driver) {
+	(*s)[uid] = Subscription{
+		Bus:     drv.Bus,
+		Address: drv.Address,
+	}
+}

server/models/clients.go

@@ -1,51 +1,44 @@
 package models
 
-import (
+// type Clients map[string]Client
-	"fmt"
 
-	"github.com/coder/websocket"
+// type Client struct {
-	"github.com/gin-gonic/gin"
+// 	Connected *bool           `json:"connected"`
-)
+// 	SndConn   *websocket.Conn `json:"-"` //sending connection
+// 	RvcConn   *websocket.Conn `json:"-"` // revieving connection
+// }
 
-type Clients map[string]Client
+// func NewClients() Clients {
+// 	return make(Clients)
+// }
 
-type Client struct {
+// // Connect a recieving websocket connection
-	Connected *bool           `json:"connected"`
+// func (c *Clients) ConnectRecievingWsConnection(id string, ctx *gin.Context) (*websocket.Conn, error) {
-	SndConn   *websocket.Conn `json:"-"` //sending connection
+// 	conn, err := websocket.Accept(ctx.Writer, ctx.Request, &websocket.AcceptOptions{
-	RvcConn   *websocket.Conn `json:"-"` // revieving connection
+// 		OriginPatterns: []string{"*"},
-}
+// 	})
 
-func NewClients() Clients {
+// 	if err != nil {
-	return make(Clients)
+// 		return nil, fmt.Errorf("error accept websocket client: %s", err)
-}
+// 	}
 
-// Connect a recieving websocket connection
+// 	b := true
-func (c *Clients) ConnectRecievingWsConnection(id string, ctx *gin.Context) (*websocket.Conn, error) {
+// 	(*c)[id] = Client{
-	conn, err := websocket.Accept(ctx.Writer, ctx.Request, &websocket.AcceptOptions{
+// 		Connected: &b,
-		OriginPatterns: []string{"*"},
+// 		RvcConn:   conn,
-	})
+// 	}
+// 	return conn, nil
+// }
 
-	if err != nil {
+// func (c *Clients) RemoveClient(id string) {
-		return nil, fmt.Errorf("error accept websocket client: %s", err)
+// 	delete(*c, id)
-	}
+// }
 
-	b := true
+// func (c *Clients) GetClientPointer(id string) *bool {
-	(*c)[id] = Client{
+// 	return (*c)[id].Connected
-		Connected: &b,
+// }
-		RvcConn:   conn,
-	}
-	return conn, nil
-}
 
-func (c *Clients) RemoveClient(id string) {
+// func (c *Clients) DisconnectRecievingWsConnection(id string, code websocket.StatusCode, reason string) {
-	delete(*c, id)
+// 	*(*c)[id].Connected = false
-}
+// 	(*c)[id].RvcConn.Close(code, reason)
-
+// }
-func (c *Clients) GetClientPointer(id string) *bool {
-	return (*c)[id].Connected
-}
-
-func (c *Clients) DisconnectRecievingWsConnection(id string, code websocket.StatusCode, reason string) {
-	*(*c)[id].Connected = false
-	(*c)[id].RvcConn.Close(code, reason)
-}

server/server.go

@@ -1,9 +1,8 @@
 package server
 
 import (
-	"fmt"
-
 	"artNet/cert"
+	"fmt"
 
 	"github.com/gin-gonic/gin"
 )
@@ -12,6 +11,17 @@ type Server struct {
 	Routes *gin.Engine
 }
 
+type Send struct {
+	Set []Set `json:"subscribe"`
+}
+
+type Set struct {
+	Path     string `json:"path"`
+	OnChange bool   `json:"onChange"`
+	Depth    int    `json:"depth"`
+	Driver   string `json:"driver"`
+}
+
 // Initialize new websocket server
 func NewServer() *Server {
 	return &Server{