paadi/tecamino-dbm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement new json_data model

Browse Source
This commit is contained in:
Adrian Zürcher
2025-04-29 08:31:06 +02:00
parent 0a137c9d86
commit 49d8d03d8a
25 changed files with 609 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
dbm/db.go Normal file
View File

@@ -0,0 +1,25 @@
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.SendError(err.Error())
c.JSON(http.StatusBadRequest, r)
return
}
r := json_dataModels.NewResponse()
r.SendMessage(fmt.Sprintf("DBM %ddatapints saved in: %v", d.GetNumbersOfDatapoints(), time.Since(s)))
c.JSON(http.StatusOK, r)
}

122
dbm/dbmHandler.go
View File

@@ -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),
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 != nil {
if err = json.Unmarshal(scanner.Bytes(), &dp); 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,18 +104,30 @@ func (d *DBMHandler) SaveDb() (err error) {
return
}
func (d *DBMHandler) CreateDatapoint(typ models.Type, value any, right models.Rights, path string) error {
if err := d.DB.CreateDatapoint(typ, value, right, path); err != nil {
return err
func (d *DBMHandler) CreateDatapoints(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
if len(sets) == 0 {
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)
return nil
d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+ndp)
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
}
@@ -127,71 +138,24 @@ func (d *DBMHandler) ImportDatapoints(dps ...*models.Datapoint) error {
}
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 {
if err := d.DB.RemoveDatapoint(path); err != nil {
return err
func (d *DBMHandler) RemoveDatapoint(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
var lsRemoved []json_dataModels.Set
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)
return nil
d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()-1)
}
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
}

82
dbm/json_data.go Normal file
View File

@@ -0,0 +1,82 @@
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.SendError(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.SendError(err.Error())
c.JSON(http.StatusBadRequest, r)
return
}
}
c.JSON(200, respond)
return
}
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.SendError(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.SendError(err.Error())
c.JSON(http.StatusBadRequest, r)
return
}
}
c.JSON(200, response)
return
}

34
dbm/publish.go
View File

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

61
dbm/subscribe.go
View File

@@ -2,45 +2,74 @@ package dbm
import (
"github.com/coder/websocket/wsjson"
"github.com/zuadi/tecamino-dbm/models"
"golang.org/x/net/context"
json_dataModels "github.com/tecamino/tecamino-json_data/models"
)
func (d *DBMHandler) Subscribe(ctx context.Context, sub *models.Subscribe, id string) {
func (d *DBMHandler) Subscribe(subs []json_dataModels.Subscribe, id string) {
if subs == nil {
return
}
d.RLock()
defer d.RUnlock()
client, ok := d.Conns.Clients[id]
if !ok {
d.Log.Error("subscribe.Subscribe", "client not found for id "+id)
return
}
response := json_dataModels.NewResponse()
for _, sub := range subs {
for _, dp := range d.DB.QueryDatapoints(sub.Depth, sub.Path) {
if sub.Driver != nil {
if dp.Drivers == nil {
continue
} else if _, ok := dp.Drivers[*sub.Driver]; !ok {
if sub.Driver != "" {
if dp.Drivers == nil || dp.Drivers[sub.Driver] == nil {
continue
}
}
dp.AddSubscribtion(id, sub)
err := wsjson.Write(ctx, d.Clients[id].Conn, models.JsonResponse{
Event: OnCreate,
response.AddSubscription(json_dataModels.Subscribe{
Uuid: dp.Uuid,
Path: dp.Path,
Value: dp.Value,
Driver: sub.Driver,
Drivers: &dp.Drivers,
})
if err != nil {
d.Log.Error("subscribe.Subscribe", err.Error())
}
}
if err := wsjson.Write(client.Ctx, client.Conn, response); 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(subs []json_dataModels.Subscribe, id string) {
if subs == nil {
return
}
d.RLock()
defer d.RUnlock()
client, ok := d.Conns.Clients[id]
if !ok {
d.Log.Error("subscribe.Subscribe", "client not found for id "+id)
return
}
response := json_dataModels.NewResponse()
for _, sub := range subs {
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)
response.AddUnsubscription(json_dataModels.Subscribe{
Uuid: dp.Uuid,
Path: dp.Path,
})
}
}
if err := wsjson.Write(client.Ctx, client.Conn, response); err != nil {
d.Log.Error("subscribe.Subscribe", err.Error())
}
return nil
}

97
dbm/system.go Normal file
View File

@@ -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, t, 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
}

66
dbm/webSocket.go
View File

@@ -1,13 +1,14 @@
package dbm
import (
"context"
"errors"
"fmt"
"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 +18,45 @@ const (
)
func (d *DBMHandler) WebSocket(c *gin.Context) {
// id, err := auth.GetIDFromAuth(c)
// if err != nil {
// d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
// return
// }
id := "test"
id, err := auth.GetIDFromQuery(c)
if err != nil {
d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromQuery: "+err.Error())
return
}
d.Log.Debug("dbmHandler.webSocket.Websocket", "authorization id token: "+id)
ctx, cancel := context.WithCancel(c.Request.Context())
defer cancel()
err := d.Clients.ConnectRecievingWsConnection(id, c)
defer d.Clients.RemoveClient(id)
err = d.Conns.ConnectRecievingWsConnection(id, c)
defer d.Conns.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 {
break
}
// Subscribe
if request.Subscribe != nil {
go func() {
for _, sub := range *request.Subscribe {
d.Subscribe(ctx, &sub, id)
}
}()
}
go d.Subscribe(request.Subscribe, id)
// Unsubscribe
if request.Unsubscribe != nil {
for _, unsub := range *request.Unsubscribe {
err = d.Unsubscribe(ctx, &unsub, id)
if err != nil {
d.Log.Error("dbmHandler.WebSocket unsubscribe", err)
break
}
}
}
go d.Unsubscribe(request.Unsubscribe, id)
if err != nil {
break
}
}
}
func (d *DBMHandler) readJsonData(ctx context.Context, id string) (*models.JsonData, error) {
var request models.JsonData
err := wsjson.Read(ctx, d.Clients[id].Conn, &request)
func (d *DBMHandler) readJsonData(id string) (request json_dataModels.Request, err error) {
client, ok := d.Conns.Clients[id]
if !ok {
return request, errors.New("client id not found")
}
err = wsjson.Read(client.Ctx, client.Conn, &request)
if err != nil {
code := websocket.CloseStatus(err)
@@ -81,11 +65,11 @@ 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
return
}

6
go.mod
View File

@@ -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.10
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

4
go.sum
View File

@@ -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.10 h1:I5xvJ8eRxX0QbMTuSHlAA16FQ8uE49OiCSsQ7Xjircc=
github.com/tecamino/tecamino-json_data v0.0.10/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=

10
main.go
View File

@@ -4,9 +4,9 @@ import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/zuadi/tecamino-dbm/args"
"github.com/zuadi/tecamino-dbm/dbm"
"github.com/zuadi/tecamino-dbm/server"
"github.com/tecamino/tecamino-dbm/args"
"github.com/tecamino/tecamino-dbm/dbm"
"github.com/tecamino/tecamino-dbm/server"
)
func main() {
@@ -26,7 +26,9 @@ 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!")

259
models/datapoints.go
View File

@@ -1,28 +1,99 @@
package models
import (
"errors"
"fmt"
"regexp"
"strings"
"time"
"github.com/zuadi/tecamino-dbm/utils"
"github.com/coder/websocket/wsjson"
"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 Type `json:"type"`
ReadWrite Rights `json:"readWrite"`
Drivers map[string]*Driver `json:"-"`
Subscribtions Subscribtions `json:"-"`
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) CreateDatapoint(typ Type, value any, rights Rights, path string) error {
parts := regexp.MustCompile(`[:]+`).Split(path, -1)
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 {
@@ -33,24 +104,46 @@ func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path str
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()
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 {
// Create new
current.Datapoints[part] = &Datapoint{
Path: strings.Join(parts, ":"),
Type: typ,
Value: typ.ConvertValue(value),
ReadWrite: rights.GetRights(),
Uuid: uuid.New(),
CreateDateTime: time.Now().UnixMilli(),
UpdateDateTime: time.Now().UnixMilli(),
Subscribtions: InitSubscribtion(),
Subscriptions: InitSubscribtion(),
}
publish, err := current.Datapoints[part].Set(strings.Join(parts, ":"), dp)
if err != nil {
return nil, err
}
created = append(created, json_dataModels.Set{
Uuid: current.Uuid,
Path: current.Path,
Type: current.Type,
Value: current.Value,
Rights: current.ReadWrite,
Driver: dp.Driver,
})
if publish {
current.Publish(conns, OnChange)
}
}
return nil
}
// Traverse or create intermediate datapoints
@@ -58,22 +151,36 @@ func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path str
current = next
} else {
newDp := &Datapoint{
Uuid: uuid.New(),
Path: strings.Join(parts[:i+1], ":"),
Type: NONE,
ReadWrite: rights.GetRights(),
Type: json_dataModels.NONE,
CreateDateTime: time.Now().UnixMilli(),
UpdateDateTime: time.Now().UnixMilli(),
Subscribtions: InitSubscribtion(),
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 nil
}
return
}
func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
parts := regexp.MustCompile(`[:]+`).Split(path, -1)
func (d *Datapoint) ImportDatapoint(conns *serverModels.Connections, dp Datapoint, path string) error {
parts := strings.Split(dp.Path, ":")
current := d
for i, part := range parts {
@@ -88,12 +195,14 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
existing.Value = current.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.Subscribtions = InitSubscribtion()
current.Datapoints[part] = dp
dp.Subscriptions = InitSubscribtion()
current.Datapoints[part] = &dp
dp.Publish(conns, OnChange)
}
return nil
}
@@ -104,7 +213,7 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
} else {
newDp := &Datapoint{
Path: strings.Join(parts[:i+1], ":"),
Type: NONE,
Type: json_dataModels.NONE,
ReadWrite: dp.ReadWrite.GetRights(),
UpdateDateTime: time.Now().UnixMilli(),
}
@@ -116,9 +225,9 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
return nil
}
func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
func (d *Datapoint) UpdateDatapointValue(conns *serverModels.Connections, value any, path string) error {
paths := regexp.MustCompile(`[:]+`).Split(path, -1)
paths := strings.Split(path, ":")
current := d
for i, part := range paths {
@@ -129,6 +238,7 @@ func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
if i == len(paths)-1 {
dp.Value = dp.Type.ConvertValue(value)
dp.UpdateDateTime = time.Now().UnixMilli()
dp.Publish(conns, OnChange)
return nil
}
current = dp
@@ -136,40 +246,38 @@ func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
return nil
}
func (d *Datapoint) RemoveDatapoint(path string) error {
parts := regexp.MustCompile(`[:]+`).Split(path, -1)
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 fmt.Errorf("invalid path: '%s'", path)
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 fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
return json_dataModels.Set{}, fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
}
current = next
}
toDelete := parts[len(parts)-1]
if _, ok := current.Datapoints[toDelete]; ok {
if dp, ok := current.Datapoints[toDelete]; ok {
dp.Publish(conns, OnDelete)
delete(current.Datapoints, toDelete)
fmt.Println("Removed datapoint:", path)
return nil
return json_dataModels.Set{
Uuid: set.Uuid,
Path: set.Path,
}, nil
}
return fmt.Errorf("datapoint '%s' not found", path)
return json_dataModels.Set{}, fmt.Errorf("datapoint '%s' not found", set.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)
}
func (d *Datapoint) GetAllDatapoints(depth uint) (dps []*Datapoint) {
var dfs func(dp *Datapoint, currentDepth uint)
dfs = func(dp *Datapoint, currentDepth uint) {
if depth == 1 {
return
} else if depth == 0 {
@@ -186,15 +294,16 @@ func (d *Datapoint) GetAllDatapoints(depth int) (dps []*Datapoint) {
}
for _, child := range dp.Datapoints {
dps = append(dps, child)
dfs(child, currentDepth+1)
}
}
dps = append(dps, d)
dfs(d, 0)
return
}
func (d *Datapoint) QueryDatapoints(depth int, path string) (dps []*Datapoint) {
func (d *Datapoint) QueryDatapoints(depth uint, path string) (dps []*Datapoint) {
parts := strings.Split(path, ":")
var dfs func(current *Datapoint, index int)
@@ -222,17 +331,17 @@ func (d *Datapoint) QueryDatapoints(depth int, path string) (dps []*Datapoint) {
return
}
func (d *Datapoint) AddSubscribtion(id string, sub *Subscribe) {
if d.Subscribtions == nil {
func (d *Datapoint) AddSubscribtion(id string, sub json_dataModels.Subscribe) {
if d.Subscriptions == nil {
return
}
if s, ok := d.Subscribtions[id]; ok {
if s, ok := d.Subscriptions[id]; ok {
s.OnCreate = sub.OnCreate
s.OnChange = sub.OnChange
s.OnDelete = sub.OnDelete
} else {
d.Subscribtions[id] = &Subscribtion{
d.Subscriptions[id] = &Subscription{
OnCreate: sub.OnCreate,
OnChange: sub.OnChange,
OnDelete: sub.OnDelete,
@@ -241,37 +350,35 @@ func (d *Datapoint) AddSubscribtion(id string, sub *Subscribe) {
}
func (d *Datapoint) RemoveSubscribtion(id string) {
if _, ok := d.Subscribtions[id]; !ok {
if _, ok := d.Subscriptions[id]; !ok {
return
}
delete(d.Subscribtions, id)
delete(d.Subscriptions, id)
}
func (d *Datapoint) AddDriver(driver, bus string, adr int) {
if d.Drivers == nil {
d.Drivers = make(map[string]*Driver)
func (d *Datapoint) Publish(conns *serverModels.Connections, eventType string) error {
if conns.Clients == nil {
return nil
}
conns.RLock()
defer conns.RUnlock()
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
for id := range d.Subscriptions {
if client, ok := conns.Clients[id]; !ok {
delete(d.Subscriptions, id)
} else {
d.Subscribtions[id] = &Subscribtion{
OnCreate: sub.OnCreate,
OnChange: sub.OnChange,
OnDelete: sub.OnDelete,
r := json_data.NewResponse()
r.AddUPublish(json_dataModels.Publish{
Event: eventType,
Uuid: d.Uuid,
Path: d.Path,
Value: d.Value,
})
err := wsjson.Write(client.Ctx, client.Conn, r)
if err != nil {
return err
}
}
}
func (d *Datapoint) GetValueUint64() uint64 {
return utils.Uint64From(d.Value)
}
return nil
}

6
models/driver.go
View File

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

6
models/get.go
View File

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

35
models/jsonData.go
View File

@@ -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,
})
}

10
models/jsonResponse.go
View File

@@ -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"`
}

6
models/query.go
View File

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

18
models/rights.go
View File

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

8
models/set.go
View File

@@ -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"`
}

10
models/subscribe.go
View File

@@ -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"`
}

8
models/subscribtion.go
View File

@@ -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 {
return make(Subscribtions)
func InitSubscribtion() Subscriptions {
return make(Subscriptions)
}

67
models/type.go
View File

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

27
server/jsonRequest.go
View File

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

51
server/models/clients.go
View File

@@ -3,7 +3,7 @@ package models
import (
"context"
"fmt"
"net/http"
"time"
"github.com/coder/websocket"
"github.com/gin-gonic/gin"
@@ -14,7 +14,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 +25,35 @@ func NewClients() Clients {
}
// Connect a recieving websocket connection
func (c *Clients) ConnectRecievingWsConnection(id string, ctx *gin.Context) error {
if _, exists := (*c)[id]; exists {
func (cl *Clients) ConnectRecievingWsConnection(id string, c *gin.Context) error {
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.WithTimeout(context.Background(), 3*time.Minute)
b := true
(*c)[id] = &Client{
Connected: &b,
(*cl)[id] = &Client{
Connected: true,
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()
}

32
server/models/connections.go Normal file
View File

@@ -0,0 +1,32 @@
package models
import (
"sync"
"github.com/coder/websocket"
"github.com/gin-gonic/gin"
)
type Connections struct {
sync.RWMutex
Clients Clients
}
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)
}

41
test/helper.go
View File

@@ -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"
}
}