updated

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

driver/artNet.go

@@ -14,9 +14,9 @@ type ArtNetDriver struct {
 	Name          string                 `yaml:"driver" json:"driver"`
 	Buses         map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
 	cfgHandler    *cfg.Cfg               `yaml:"-" json:"-"`
-	Conn          *client.Client         `yaml:"-"`
+	Conn          *client.Client         `yaml:"-" json:"-"`
-	Subscriptions models.Subscriptions   `yaml:"-"`
+	Subscriptions models.Subscriptions   `yaml:"-" json:"-"`
-	Log           *logging.Logger        `yaml:"-"`
+	Log           *logging.Logger        `yaml:"-" json:"-"`
 }
 
 // initialize new Art-Net driver
@@ -72,7 +72,6 @@ func (d *ArtNetDriver) LoadCfg() error {
 // adds new Art-Net bus/interface to driver port 0 = 6454 (default art-net)
 func (d *ArtNetDriver) NewBus(name, ip string, port int) *models.Bus {
 	b := models.NewBus(name, ip, port)
-	b.Start(d.Log)
 	d.Buses[name] = b
 	return b
 }

driver/bus.go

@@ -8,6 +8,7 @@ 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"
 )
 
@@ -26,123 +27,132 @@ 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.SendError(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.SendError("wrong ip '" + busPayload.Ip + "'")
-	} else if addr := net.ParseIP(payload.Ip); addr == nil {
+		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.SendError("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{
+	r := json_data.NewResponse()
-		"message": fmt.Sprintf("bus '%s' successfully created with ip: %s and on port: %d", bus.Name, bus.Ip, bus.GetPort()),
+	r.SendMessage(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.SendError("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"})
-		return
-	}
-
-	if _, ok := d.Buses[payload.Name]; !ok {
 		r := json_dataModels.NewResponse()
-		r.SendMessage("bus " + payload.Name + " not found")
+		r.SendMessage("bus " + busPayload.Name + " not found")
 		c.JSON(http.StatusOK, r)
 		return
 	} else {
-		delete(d.Buses, payload.Name)
+		delete(d.Buses, busPayload.Name)
 	}
 	r := json_dataModels.NewResponse()
-	r.SendMessage(fmt.Sprintf("bus '%s' successfully removed", payload.Name))
+	r.SendMessage(fmt.Sprintf("bus '%s' successfully removed", busPayload.Name))
 	c.JSON(http.StatusOK, r)
 	d.cfgHandler.SaveCfg(*d)
 }
 
 func (d *ArtNetDriver) Start(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.SendError("id: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
 		return
 	}
 
-	var payload models.Bus
+	busPayload := models.Bus{}
-
+	if 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 == "" {
+	d.Buses[busPayload.Name].Start(d.Log)
-		c.JSON(http.StatusBadRequest, gin.H{"error": "bus name missing"})
-		return
-	}
-
-	d.Buses[payload.Name].Start(d.Log)
 
 	r := json_dataModels.NewResponse()
-	r.SendMessage(fmt.Sprintf("bus '%s' running", payload.Name))
+	r.SendMessage(fmt.Sprintf("bus '%s' running", busPayload.Name))
 	c.JSON(http.StatusOK, r)
 	d.cfgHandler.SaveCfg(*d)
 }
 
 func (d *ArtNetDriver) Stop(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.SendError("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 == "" {
+	d.Buses[busPayload.Name].Stop()
-		c.JSON(http.StatusBadRequest, gin.H{"error": "bus name missing"})
-		return
-	}
-
-	d.Buses[payload.Name].Stop()
 
 	r := json_dataModels.NewResponse()
-	r.SendMessage(fmt.Sprintf("bus '%s' stopped", payload.Name))
+	r.SendMessage(fmt.Sprintf("bus '%s' stopped", busPayload.Name))
 	c.JSON(http.StatusOK, r)
 	d.cfgHandler.SaveCfg(*d)
 }
+
+func (d *ArtNetDriver) Status(c *gin.Context) {
+	_, err := auth.GetIDFromQuery(c)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SendError("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.SendMessage(fmt.Sprintf("bus '%s' %s", busPayload.Name, state))
+	c.JSON(http.StatusOK, r)
+}

driver/webSocket.go

@@ -1,63 +1,49 @@
 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) {
+//func (d *ArtNetDriver) Websocket(c *gin.Context) {
-	id, err := auth.GetIDFromAuth(c)
+// id, err := auth.GetIDFromQuery(c)
-	if err != nil {
+// if err != nil {
-		d.Log.Error("artNet.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
+// 	d.Log.Error("artNet.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
-		log.Println("error id:", err)
+// 	return
-		return
+// }
-	}
+// d.Log.Debug("artNet.webSocket.Websocket", "authorization id token: "+id)
-	d.Log.Debug("artNet.webSocket.Websocket", "authorization id token: "+id)
 
-	ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Minute)
+// ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Minute)
-	defer cancel()
+// defer cancel()
-	conn, err := d.Connections.ConnectRecievingWsConnection(id, c)
+// conn, err := d.Connections.ConnectRecievingWsConnection(id, c)
-	if err != nil {
+// if err != nil {
-		d.Log.Error("artNet.webSocket.Websocket", "error connecting recieving websocket conection: "+err.Error())
+// 	d.Log.Error("artNet.webSocket.Websocket", "error connecting recieving websocket conection: "+err.Error())
-		return
+// 	return
-	}
+// }
-	defer d.Connections.DisconnectRecievingWsConnection(id, websocket.StatusInternalError, "Internal error")
+// defer d.Connections.DisconnectRecievingWsConnection(id, websocket.StatusInternalError, "Internal error")
 
-	var request models.JsonData
+// var request any
-	//Read loop
+// //Read loop
-	for {
+// for {
 
-		err := wsjson.Read(ctx, conn, &request)
+// 	err := wsjson.Read(ctx, conn, &request)
-		if err != nil {
+// 	if err != nil {
-			d.Log.Error("artNet.webSocket.Websocket", "read error:"+err.Error())
+// 		d.Log.Error("artNet.webSocket.Websocket", "read error:"+err.Error())
-			log.Println("WebSocket read error:", err)
+// 		log.Println("WebSocket read error:", err)
-			break
+// 		break
-		}
+// 	}
-
+// 	fmt.Println(request)
-		// Set
+// Set
-		if request.Set != nil {
+// if request.Set != nil {
-			for _, set := range *request.Set {
+// 	for _, set := range *request.Set {
-				if err = d.SetValue(set); err != nil {
+// 		if err = d.SetValue(set); err != nil {
-					d.Log.Error("artNet.webSocket.Websocket", "set value error"+err.Error())
+// 			d.Log.Error("artNet.webSocket.Websocket", "set value error"+err.Error())
-					log.Println(err)
+// 			log.Println(err)
-					continue
+// 			continue
-				}
+// 		}
-				time.Sleep(23 * time.Millisecond)
+// 		time.Sleep(23 * time.Millisecond)
-			}
+// 	}
-		}
+// }
-	}
+// 	}
-}
+// }

main.go

@@ -6,6 +6,7 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/gin-gonic/gin"
 )
@@ -14,9 +15,11 @@ 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")
 	flag.Parse()
 
@@ -38,21 +41,28 @@ 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.GET("/", func(c *gin.Context) {
 		c.String(200, "ArtNet Driver WebSocket Server is running!")
 	})
 
-	artNetDriver.Log.Info("main", fmt.Sprintf("listen on %d", *port))
+	go func() {
-	// start http server
+		if err := s.ServeHttp(*wsPort); err != nil {
-	if err := s.ServeHttp(*port); err != nil {
+			artNetDriver.Log.Error("main", err.Error())
-		artNetDriver.Log.Error("main", "error http server "+err.Error())
+		}
-		panic(err)
+	}()
+
+	artNetDriver.Log.Info("main", fmt.Sprintf("connect to server  ws://%s:%d with id %s", *serverIp, serverPort, DriverName))
+	// connect to server
+	for {
+		artNetDriver.Log.Error("main", artNetDriver.Connect(*serverIp, DriverName, *serverPort))
+		time.Sleep(10 * time.Second)
 	}
+
 }

models/bus.go

@@ -2,11 +2,15 @@ package models
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net"
+	"net/http"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/tatsushid/go-fastping"
+	json_data "github.com/tecamino/tecamino-json_data"
 	"github.com/tecamino/tecamino-logger/logging"
 )
 
@@ -135,6 +139,11 @@ func (b *Bus) Stop() {
 	}
 }
 
+// status bus
+func (b *Bus) Status() bool {
+	return b.Watchdog != nil
+}
+
 // send dmx data
 func (b *Bus) SendData() error {
 	if !b.Reachable {
@@ -156,6 +165,24 @@ func (b *Bus) SendData() error {
 	return err
 }
 
+func (b *Bus) ParsePayload(c *gin.Context) error {
+
+	if err := c.BindJSON(b); err != nil {
+		r := json_data.NewResponse()
+		r.SendError("json: " + err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return err
+	}
+
+	if b.Name == "" {
+		r := json_data.NewResponse()
+		r.SendError("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)

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{