logging and sig catching

This commit is contained in:
William Clark 2022-11-12 16:22:55 +00:00
parent ef9a4c1c24
commit d65e7e6b6d
12 changed files with 128 additions and 40 deletions

View File

@ -1,15 +1,13 @@
[TH7] [TH7]
port = 8080 port = 8080
logfreq = 60
cache = true cache = true
LED = false LED = false
logfreq = 60 debug = true
[DB] [DB]
type = "mysql" type = "sqlite3"
user = "root" path = "test.db"
pass = "admin123"
host = "localhost"
port = 3306
[Channel_1] [Channel_1]
type = 'K' type = 'K'

View File

@ -67,11 +67,13 @@ func Load() (config.Config, error) {
v.SetDefault("TH7.cache", true) v.SetDefault("TH7.cache", true)
v.SetDefault("TH7.LED", true) v.SetDefault("TH7.LED", true)
v.SetDefault("TH7.logfreq", 60) v.SetDefault("TH7.logfreq", 60)
v.SetDefault("TH7.debug", false)
cfg.Board.Port = v.GetInt("TH7.port") cfg.Board.Port = v.GetInt("TH7.port")
cfg.Board.Cache = v.GetBool("TH7.cache") cfg.Board.Cache = v.GetBool("TH7.cache")
cfg.Board.Led = v.GetBool("TH7.LED") cfg.Board.Led = v.GetBool("TH7.LED")
cfg.Board.Logfreq = v.GetInt("TH7.loqfreq") cfg.Board.Logfreq = v.GetInt("TH7.logfreq")
cfg.Board.Debug = v.GetBool("TH7.debug")
cfg.Channels = make([]config.Channel, 0) cfg.Channels = make([]config.Channel, 0)
var c config.Channel var c config.Channel

15
core/adapter.go Normal file
View File

@ -0,0 +1,15 @@
package core
import (
"th7/data/config"
"th7/ports"
)
func NewAdapter(pcb ports.PCBPort, cfg config.Config) (ports.CorePort, error) {
if cfg.Board.Debug {
return NewDummyAdapter(pcb), nil
} else {
return NewTH7Adapter(pcb, cfg), nil
}
}

View File

@ -2,41 +2,26 @@ package core
import ( import (
"sync" "sync"
"th7/data/config"
"th7/data/core" "th7/data/core"
"th7/ports" "th7/ports"
) )
type TH7Adapter struct { type TH7Adapter struct {
pcbPort ports.PCBPort pcbPort ports.PCBPort
dbPort ports.DBPort
mu sync.Mutex mu sync.Mutex
data core.Data data core.Data
run bool
} }
func NewTH7Adapter(pcbPort ports.PCBPort, dbPort ports.DBPort) *TH7Adapter { func NewTH7Adapter(pcbPort ports.PCBPort, cfg config.Config) *TH7Adapter {
var adapter TH7Adapter var adapter TH7Adapter
adapter.pcbPort = pcbPort adapter.pcbPort = pcbPort
adapter.dbPort = dbPort
adapter.run = true
go startDBLoggerService(&adapter)
go startProxyService(&adapter)
return &adapter return &adapter
} }
func startProxyService(t *TH7Adapter) {
}
func startDBLoggerService(t *TH7Adapter) {
}
func (t *TH7Adapter) GetChannel(id int) (core.Channel, error) { func (t *TH7Adapter) GetChannel(id int) (core.Channel, error) {
t.mu.Lock() t.mu.Lock()
defer t.mu.Unlock() defer t.mu.Unlock()

View File

@ -18,6 +18,7 @@ type TH7 struct {
Cache bool `json:"cache"` Cache bool `json:"cache"`
Led bool `json:"LED"` Led bool `json:"LED"`
Logfreq int `json:"logfreq"` Logfreq int `json:"logfreq"`
Debug bool `json:"debug"`
} }
type Config struct { type Config struct {

23
db/adapter.go Normal file
View File

@ -0,0 +1,23 @@
package db
import (
"errors"
"fmt"
"th7/ports"
)
func NewAdapter(db map[string]interface{}) (ports.DBPort, error) {
// if no "type" is given, use dummy
if _, ok := db["type"]; !ok {
return NewDummyAdapter()
}
db_type := fmt.Sprint(db["type"])
switch db_type {
case "sqlite3":
return NewSQLite3Adapter(db)
}
return &DummyAdapter{}, errors.New("unknown db type")
}

View File

@ -2,13 +2,12 @@ package db
import ( import (
"fmt" "fmt"
"th7/data/core"
) )
type DummyAdapter struct { type DummyAdapter struct {
} }
func NewDummyAdapter(dbInfo map[string]interface{}) (*DummyAdapter, error) { func NewDummyAdapter() (*DummyAdapter, error) {
return &DummyAdapter{}, nil return &DummyAdapter{}, nil
} }
@ -16,6 +15,6 @@ func (d *DummyAdapter) Close() {
fmt.Println("Closing DB ...") fmt.Println("Closing DB ...")
} }
func (d *DummyAdapter) Save(data core.Data) { func (d *DummyAdapter) Save() {
fmt.Println("Saving data to DB ...") fmt.Println("Saving data to DB ...")
} }

38
db/logger/logger.go Normal file
View File

@ -0,0 +1,38 @@
package logger
import (
"th7/ports"
"time"
)
type Logger struct {
core ports.CorePort
db ports.DBPort
period int
run bool
}
func doLogging(log *Logger) {
duration := time.Duration(log.period) * time.Second
for log.run {
time.Sleep(duration)
log.db.Save()
}
}
func NewLogger(core ports.CorePort, db ports.DBPort, period int) *Logger {
var logger Logger
logger.db = db
logger.core = core
logger.period = period
logger.run = true
go doLogging(&logger)
return &logger
}
func (l *Logger) Stop() {
l.run = false
}

View File

@ -2,9 +2,9 @@ package db
import ( import (
"database/sql" "database/sql"
"errors"
"fmt" "fmt"
"sync" "sync"
"th7/data/core"
_ "github.com/mattn/go-sqlite3" _ "github.com/mattn/go-sqlite3"
) )
@ -14,10 +14,17 @@ type SQLite3Adapter struct {
db *sql.DB db *sql.DB
} }
func NewSQLite3Adapter(path string) (*SQLite3Adapter, error) { func NewSQLite3Adapter(dbInfo map[string]interface{}) (*SQLite3Adapter, error) {
var adapter SQLite3Adapter var adapter SQLite3Adapter
// if path is given ...
if _, ok := dbInfo["path"]; !ok {
return &adapter, errors.New("sqlite3 requires a path config variable")
}
path := fmt.Sprint(dbInfo["path"])
db, err := sql.Open("sqlite3", path) db, err := sql.Open("sqlite3", path)
if err != nil { if err != nil {
return &adapter, err return &adapter, err
@ -45,9 +52,9 @@ func (ad *SQLite3Adapter) Close() {
ad.db.Close() ad.db.Close()
} }
func (ad *SQLite3Adapter) Save(data core.Data) { func (ad *SQLite3Adapter) Save() {
ad.mu.Lock() ad.mu.Lock()
defer ad.mu.Unlock() defer ad.mu.Unlock()
fmt.Println("TODO save data...", data) fmt.Println("TODO save data...")
} }

24
main.go
View File

@ -3,9 +3,13 @@ package main
import ( import (
"fmt" "fmt"
"log" "log"
"os"
"os/signal"
"syscall"
"th7/config" "th7/config"
"th7/core" "th7/core"
"th7/db" "th7/db"
"th7/db/logger"
"th7/pcb" "th7/pcb"
"th7/ports" "th7/ports"
"th7/web" "th7/web"
@ -19,6 +23,9 @@ func main() {
var webPort ports.WebPort var webPort ports.WebPort
var err error var err error
kill := make(chan os.Signal, 1)
signal.Notify(kill, syscall.SIGTERM, syscall.SIGINT)
config, err := config.Load() config, err := config.Load()
if err != nil { if err != nil {
log.Fatalf("Error loading config: %v", err) log.Fatalf("Error loading config: %v", err)
@ -26,20 +33,29 @@ func main() {
fmt.Println(config) fmt.Println(config)
pcbPort, err = pcb.NewDummyAdapter(config.Board.Led) pcbPort, err = pcb.NewAdapter(config.Board.Led)
if err != nil { if err != nil {
log.Fatalf("Fatal error: %v\n", err) log.Fatalf("Fatal error: %v\n", err)
} }
defer pcbPort.Deinit() defer pcbPort.Deinit()
dbPort, err = db.NewDummyAdapter(config.DB) dbPort, err = db.NewAdapter(config.DB)
if err != nil { if err != nil {
log.Fatalf("Fatal error: %v\n", err) log.Fatalf("Fatal error: %v\n", err)
} }
defer dbPort.Close() defer dbPort.Close()
corePort = core.NewDummyAdapter(pcbPort) corePort, err = core.NewAdapter(pcbPort, config)
if err != nil {
log.Fatalf("Error starting TH7 Adapter: %v\n", err)
}
logger := logger.NewLogger(corePort, dbPort, config.Board.Logfreq)
defer logger.Stop()
webPort = web.NewGinAdapter(corePort) webPort = web.NewGinAdapter(corePort)
webPort.Run() go webPort.Run()
sig := <-kill
log.Printf("Caught signal %v", sig)
} }

8
pcb/adapter.go Normal file
View File

@ -0,0 +1,8 @@
package pcb
import "th7/ports"
func NewAdapter(LED bool) (ports.PCBPort, error) {
return NewDummyAdapter(LED)
}

View File

@ -1,10 +1,6 @@
package ports package ports
import (
"th7/data/core"
)
type DBPort interface { type DBPort interface {
Close() Close()
Save(core.Data) Save()
} }