From 5d0a210e6dc91cb9ac2728ff9eb08b447b4da5e7 Mon Sep 17 00:00:00 2001 From: Pierre-Olivier Mercier Date: Sun, 12 Nov 2023 21:25:57 +0100 Subject: [PATCH] Initial commit --- .drone-manifest.yml | 22 +++ .drone.yml | 116 +++++++++++++++ .gitignore | 4 + api/routes.go | 14 ++ api/sources.go | 84 +++++++++++ api/volume.go | 289 ++++++++++++++++++++++++++++++++++++ app.go | 69 +++++++++ config/cli.go | 44 ++++++ config/config.go | 28 ++++ config/env.go | 21 +++ go.mod | 32 ++++ go.sum | 86 +++++++++++ main.go | 34 +++++ sources/amp1_gpio/source.go | 73 +++++++++ sources/interfaces.go | 13 ++ sources/mpv/source.go | 69 +++++++++ 16 files changed, 998 insertions(+) create mode 100644 .drone-manifest.yml create mode 100644 .drone.yml create mode 100644 .gitignore create mode 100644 api/routes.go create mode 100644 api/sources.go create mode 100644 api/volume.go create mode 100644 app.go create mode 100644 config/cli.go create mode 100644 config/config.go create mode 100644 config/env.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 main.go create mode 100644 sources/amp1_gpio/source.go create mode 100644 sources/interfaces.go create mode 100644 sources/mpv/source.go diff --git a/.drone-manifest.yml b/.drone-manifest.yml new file mode 100644 index 0000000..70818c7 --- /dev/null +++ b/.drone-manifest.yml @@ -0,0 +1,22 @@ +image: registry.nemunai.re/hathoris:{{#if build.tag}}{{trimPrefix "v" build.tag}}{{else}}latest{{/if}} +{{#if build.tags}} +tags: +{{#each build.tags}} + - {{this}} +{{/each}} +{{/if}} +manifests: + - image: registry.nemunai.re/hathoris:{{#if build.tag}}{{trimPrefix "v" build.tag}}-{{/if}}linux-amd64 + platform: + architecture: amd64 + os: linux + - image: registry.nemunai.re/hathoris:{{#if build.tag}}{{trimPrefix "v" build.tag}}-{{/if}}linux-arm64 + platform: + architecture: arm64 + os: linux + variant: v8 + - image: registry.nemunai.re/hathoris:{{#if build.tag}}{{trimPrefix "v" build.tag}}-{{/if}}linux-arm + platform: + architecture: arm + os: linux + variant: v7 diff --git a/.drone.yml b/.drone.yml new file mode 100644 index 0000000..063935b --- /dev/null +++ b/.drone.yml @@ -0,0 +1,116 @@ +--- +kind: pipeline +type: docker +name: build-arm + +platform: + os: linux + arch: arm + +workspace: + base: /go + path: src/git.nemunai.re/nemunaire/hathoris + +steps: +- name: build front + image: node:20-alpine + commands: + - mkdir deploy + - cd ui + - npm install --network-timeout=100000 + - npm run build + - tar chjf ../deploy/static.tar.bz2 build + +- name: build + image: golang:1-alpine + commands: + - apk --no-cache add alsa-lib-dev build-base git pkgconf + - go get -v -d + - go vet -v + - go build -v -ldflags '-w -X main.Version=${DRONE_BRANCH}-${DRONE_COMMIT} -X main.build=${DRONE_BUILD_NUMBER}' -o deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH} + - ln deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH} hathoris + when: + event: + exclude: + - tag + +- name: build armv7 tag + image: golang:1-alpine + commands: + - apk --no-cache add alsa-lib-dev build-base git pkgconf + - go get -v -d + - go vet -v + - go build -v -ldflags '-w -X main.Version=${DRONE_TAG##v} -X main.build=${DRONE_BUILD_NUMBER}' -o deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH}v7 + - ln deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH}v7 hathoris + when: + event: + - tag + +- name: build armv6 tag + image: golang:1-alpine + commands: + - apk --no-cache add alsa-lib-dev build-base git pkgconf + - go build -v -tags netgo -ldflags '-w -X main.Version=${DRONE_TAG##v} -X main.build=${DRONE_BUILD_NUMBER}' -o deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH}hf + environment: + CGO_ENABLED: 0 + GOARM: 6 + when: + event: + - tag + +- name: gitea release + image: plugins/gitea-release:linux-arm + settings: + api_key: + from_secret: gitea_api_key + base_url: https://git.nemunai.re/ + files: + - deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH}hf + - deploy/hathoris-${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH}v7 + when: + event: + - tag + +- name: docker + image: plugins/docker:linux-arm + settings: + registry: registry.nemunai.re + repo: registry.nemunai.re/hathoris + auto_tag: true + auto_tag_suffix: ${DRONE_STAGE_OS}-${DRONE_STAGE_ARCH} + dockerfile: Dockerfile-norebuild + username: + from_secret: docker_username + password: + from_secret: docker_password + +trigger: + event: + - cron + - push + - tag + +--- +kind: pipeline +name: docker-manifest + +steps: +- name: publish on Docker Hub + image: plugins/manifest + settings: + auto_tag: true + ignore_missing: true + spec: .drone-manifest.yml + username: + from_secret: docker_username + password: + from_secret: docker_password + +trigger: + event: + - cron + - push + - tag + +depends_on: +- build-arm diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d5d9197 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/hathoris +/vendor +/ui/build +/ui/node_modules \ No newline at end of file diff --git a/api/routes.go b/api/routes.go new file mode 100644 index 0000000..cb7babb --- /dev/null +++ b/api/routes.go @@ -0,0 +1,14 @@ +package api + +import ( + "github.com/gin-gonic/gin" + + "git.nemunai.re/nemunaire/hathoris/config" +) + +func DeclareRoutes(router *gin.Engine, cfg *config.Config) { + apiRoutes := router.Group("/api") + + declareSourcesRoutes(cfg, apiRoutes) + declareVolumeRoutes(cfg, apiRoutes) +} diff --git a/api/sources.go b/api/sources.go new file mode 100644 index 0000000..e22f078 --- /dev/null +++ b/api/sources.go @@ -0,0 +1,84 @@ +package api + +import ( + "fmt" + "net/http" + + "github.com/gin-gonic/gin" + + "git.nemunai.re/nemunaire/hathoris/config" + "git.nemunai.re/nemunaire/hathoris/sources" +) + +type SourceState struct { + Name string `json:"name"` + Enabled bool `json:"enabled"` + Active *bool `json:"active,omitempty"` +} + +func declareSourcesRoutes(cfg *config.Config, router *gin.RouterGroup) { + router.GET("/sources", func(c *gin.Context) { + ret := map[string]*SourceState{} + + for k, src := range sources.SoundSources { + ret[k] = &SourceState{ + Name: src.GetName(), + Enabled: src.IsEnabled(), + } + } + + c.JSON(http.StatusOK, ret) + }) + + sourcesRoutes := router.Group("/sources/:source") + sourcesRoutes.Use(SourceHandler) + + sourcesRoutes.GET("", func(c *gin.Context) { + src := c.MustGet("source").(sources.SoundSource) + + active := src.IsActive() + + c.JSON(http.StatusOK, &SourceState{ + Name: src.GetName(), + Enabled: src.IsEnabled(), + Active: &active, + }) + }) + sourcesRoutes.GET("/settings", func(c *gin.Context) { + c.JSON(http.StatusOK, c.MustGet("source")) + }) + sourcesRoutes.POST("/enable", func(c *gin.Context) { + src := c.MustGet("source").(sources.SoundSource) + + err := src.Enable() + if err != nil { + c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to enable the source: %s", err.Error())}) + return + } + + c.JSON(http.StatusOK, true) + }) + sourcesRoutes.POST("/disable", func(c *gin.Context) { + src := c.MustGet("source").(sources.SoundSource) + + err := src.Disable() + if err != nil { + c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to disable the source: %s", err.Error())}) + return + } + + c.JSON(http.StatusOK, true) + }) +} + +func SourceHandler(c *gin.Context) { + src, ok := sources.SoundSources[c.Param("source")] + if !ok { + c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": fmt.Sprintf("Source not found: %s", c.Param("source"))}) + return + } + + c.Set("source", src) + + c.Next() +} diff --git a/api/volume.go b/api/volume.go new file mode 100644 index 0000000..3623afe --- /dev/null +++ b/api/volume.go @@ -0,0 +1,289 @@ +package api + +import ( + "bufio" + "fmt" + "net/http" + "os/exec" + "strconv" + "strings" + + "github.com/gin-gonic/gin" + + "git.nemunai.re/nemunaire/hathoris/config" +) + +func declareVolumeRoutes(cfg *config.Config, router *gin.RouterGroup) { + router.GET("/mixer", func(c *gin.Context) { + cnt, err := parseAmixerContent() + if err != nil { + c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()}) + return + } + + c.JSON(http.StatusOK, cnt) + }) + + mixerRoutes := router.Group("/mixer/:mixer") + mixerRoutes.Use(MixerHandler) + + mixerRoutes.GET("", func(c *gin.Context) { + cc := c.MustGet("mixer").(*CardControl) + + c.JSON(http.StatusOK, cc.ToCardControlState()) + }) + mixerRoutes.POST("/values", func(c *gin.Context) { + cc := c.MustGet("mixer").(*CardControl) + + var valuesINT []interface{} + + err := c.BindJSON(&valuesINT) + if err != nil { + c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": fmt.Sprintf("Unable to parse values: %s", err.Error())}) + return + } + + var values []string + for _, v := range valuesINT { + if t, ok := v.(int64); ok { + values = append(values, strconv.FormatInt(t, 10)) + } else if t, ok := v.(float64); ok { + values = append(values, fmt.Sprintf("%f", t)) + } else if t, ok := v.(bool); ok { + if t { + values = append(values, "on") + } else { + values = append(values, "off") + } + } + } + + err = cc.CsetAmixer(values...) + if err != nil { + c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to set values: %s", err.Error())}) + return + } + + c.JSON(http.StatusOK, values) + }) +} + +func MixerHandler(c *gin.Context) { + mixers, err := parseAmixerContent() + if err != nil { + c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()}) + return + } + + mixer := c.Param("mixer") + + for _, m := range mixers { + if strconv.FormatInt(m.NumID, 10) == mixer || m.Name == mixer { + c.Set("mixer", m) + c.Next() + return + } + } + + c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Mixer not found"}) +} + +type CardControl struct { + NumID int64 + Interface string + Name string + Type string + Access string + NValues int64 + Min int64 + Max int64 + Step int64 + DBScale CardControldBScale + Values []string + Items []string +} + +func (cc *CardControl) parseAmixerField(key, value string) (err error) { + switch key { + case "numid": + cc.NumID, err = strconv.ParseInt(value, 10, 64) + case "iface": + cc.Interface = value + case "name": + cc.Name = value + case "type": + cc.Type = value + case "access": + cc.Access = value + case "values": + cc.NValues, err = strconv.ParseInt(value, 10, 64) + case "min": + cc.Min, err = strconv.ParseInt(value, 10, 64) + case "max": + cc.Max, err = strconv.ParseInt(value, 10, 64) + case "step": + cc.Step, err = strconv.ParseInt(value, 10, 64) + } + + return +} + +func (cc *CardControl) ToCardControlState() *CardControlState { + ccs := &CardControlState{ + NumID: cc.NumID, + Type: cc.Type, + Name: cc.Name, + Items: cc.Items, + } + + // Convert values + for _, v := range cc.Values { + if cc.Type == "INTEGER" { + if tmp, err := strconv.ParseFloat(v, 10); err == nil { + ccs.Current = append(ccs.Current, tmp) + } + } else if cc.Type == "BOOLEAN" { + if v == "on" { + ccs.Current = append(ccs.Current, true) + } else { + ccs.Current = append(ccs.Current, false) + } + } + } + + if cc.DBScale.Min != 0 { + ccs.Min = cc.DBScale.Min + ccs.Unit = "dB" + } else if cc.Min != 0 { + ccs.Min = float64(cc.Min) + } + + if cc.DBScale.Step != 0 { + ccs.Step = cc.DBScale.Step + ccs.Unit = "dB" + } else if cc.Step != 0 { + ccs.Step = float64(cc.Step) + } else { + ccs.Step = 1.0 + } + + if cc.Max != 0 { + ccs.Max = ccs.Min + ccs.Step*float64(cc.Max-cc.Min) + } + + return ccs +} + +type CardControldBScale struct { + Min float64 + Step float64 + Mute int64 +} + +func (cc *CardControldBScale) parseAmixerField(key, value string) (err error) { + switch key { + case "min": + cc.Min, err = strconv.ParseFloat(strings.TrimSuffix(value, "dB"), 10) + case "step": + cc.Step, err = strconv.ParseFloat(strings.TrimSuffix(value, "dB"), 10) + case "mute": + cc.Mute, err = strconv.ParseInt(value, 10, 64) + } + + return +} + +type CardControlState struct { + NumID int64 + Name string + Type string + Min float64 + Max float64 + Step float64 + Unit string `json:"unit,omitempty"` + Current []interface{} `json:"values,omitempty"` + Items []string `json:"items,omitempty"` +} + +func parseAmixerContent() ([]*CardControl, error) { + cmd := exec.Command("amixer", "-c1", "contents") + + stdout, err := cmd.StdoutPipe() + if err != nil { + return nil, err + } + if err := cmd.Start(); err != nil { + return nil, err + } + + var ret []*CardControl + + fscanner := bufio.NewScanner(stdout) + for fscanner.Scan() { + line := fscanner.Text() + + if strings.HasPrefix(line, " ; Item #") { + cc := ret[len(ret)-1] + cc.Items = append(cc.Items, strings.TrimSuffix(line[strings.Index(line, "'")+1:], "'")) + } else if strings.HasPrefix(line, " :") { + cc := ret[len(ret)-1] + line = strings.TrimPrefix(line, " : ") + + kv := strings.SplitN(line, "=", 2) + if kv[0] == "values" { + cc.Values = strings.Split(kv[1], ",") + } + } else if strings.HasPrefix(line, " |") || strings.HasPrefix(line, " |") { + cc := ret[len(ret)-1] + line = strings.TrimSpace(line) + if strings.HasPrefix(line, "| dBscale-") { + line = strings.TrimPrefix(line, "| dBscale-") + + fields := strings.Split(line, ",") + + var scale CardControldBScale + for _, field := range fields { + kv := strings.SplitN(field, "=", 2) + scale.parseAmixerField(kv[0], kv[1]) + } + cc.DBScale = scale + } + } else { + var cc *CardControl + + if strings.HasPrefix(line, "numid=") { + cc = &CardControl{} + ret = append(ret, cc) + } else { + cc = ret[len(ret)-1] + line = strings.TrimPrefix(line, " ; ") + } + + fields := strings.Split(line, ",") + + for _, field := range fields { + kv := strings.SplitN(field, "=", 2) + cc.parseAmixerField(kv[0], kv[1]) + } + } + } + + err = cmd.Wait() + return ret, err +} + +func (cc *CardControl) CsetAmixer(values ...string) error { + opts := []string{ + "-c1", + "cset", + fmt.Sprintf("numid=%d", cc.NumID), + } + opts = append(opts, values...) + cmd := exec.Command("amixer", opts...) + + if err := cmd.Start(); err != nil { + return err + } + + return cmd.Wait() +} diff --git a/app.go b/app.go new file mode 100644 index 0000000..7930d6e --- /dev/null +++ b/app.go @@ -0,0 +1,69 @@ +package main + +import ( + "context" + "log" + "net/http" + "time" + + "github.com/gin-gonic/gin" + + "git.nemunai.re/nemunaire/hathoris/api" + "git.nemunai.re/nemunaire/hathoris/config" + "git.nemunai.re/nemunaire/hathoris/ui" +) + +type App struct { + cfg *config.Config + router *gin.Engine + srv *http.Server +} + +func NewApp(cfg *config.Config) *App { + if cfg.DevProxy == "" { + gin.SetMode(gin.ReleaseMode) + } + gin.ForceConsoleColor() + router := gin.Default() + + router.Use(func(c *gin.Context) { + c.Next() + }) + + // Prepare struct + app := &App{ + cfg: cfg, + router: router, + } + + // Register routes + ui.DeclareRoutes(router, cfg) + ui.DeclareNoJSRoutes(router, cfg) + api.DeclareRoutes(router, cfg) + + router.GET("/api/version", func(c *gin.Context) { + c.JSON(http.StatusOK, gin.H{"version": Version}) + }) + + return app +} + +func (app *App) Start() { + app.srv = &http.Server{ + Addr: app.cfg.Bind, + Handler: app.router, + } + + log.Printf("Ready, listening on %s\n", app.cfg.Bind) + if err := app.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { + log.Fatalf("listen: %s\n", err) + } +} + +func (app *App) Stop() { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := app.srv.Shutdown(ctx); err != nil { + log.Fatal("Server Shutdown:", err) + } +} diff --git a/config/cli.go b/config/cli.go new file mode 100644 index 0000000..64b4f10 --- /dev/null +++ b/config/cli.go @@ -0,0 +1,44 @@ +package config + +import ( + "flag" +) + +// declareFlags registers flags for the structure Options. +func (c *Config) declareFlags() { + flag.StringVar(&c.BaseURL, "baseurl", c.BaseURL, "URL prepended to each URL") + flag.StringVar(&c.Bind, "bind", c.Bind, "Bind port/socket") + flag.StringVar(&c.DevProxy, "dev", c.DevProxy, "Use ui directory instead of embedded assets") + + // Others flags are declared in some other files when they need specials configurations +} + +func Consolidated() (cfg *Config, err error) { + // Define defaults options + cfg = &Config{ + Bind: "127.0.0.1:8080", + } + + cfg.declareFlags() + + // Then, overwrite that by what is present in the environment + err = cfg.FromEnv() + if err != nil { + return + } + + // Finaly, command line takes precedence + err = cfg.parseCLI() + if err != nil { + return + } + + return +} + +// parseCLI parse the flags and treats extra args as configuration filename. +func (c *Config) parseCLI() error { + flag.Parse() + + return nil +} diff --git a/config/config.go b/config/config.go new file mode 100644 index 0000000..aa5734d --- /dev/null +++ b/config/config.go @@ -0,0 +1,28 @@ +package config + +import ( + "flag" + "strings" +) + +type Config struct { + DevProxy string + Bind string + BaseURL string +} + +// parseLine treats a config line and place the read value in the variable +// declared to the corresponding flag. +func (c *Config) parseLine(line string) (err error) { + fields := strings.SplitN(line, "=", 2) + orig_key := strings.TrimSpace(fields[0]) + value := strings.TrimSpace(fields[1]) + + key := strings.TrimPrefix(orig_key, "HATHORIS_") + key = strings.Replace(key, "_", "-", -1) + key = strings.ToLower(key) + + err = flag.Set(key, value) + + return +} diff --git a/config/env.go b/config/env.go new file mode 100644 index 0000000..98e85db --- /dev/null +++ b/config/env.go @@ -0,0 +1,21 @@ +package config + +import ( + "fmt" + "os" + "strings" +) + +// FromEnv analyzes all the environment variables to find each one +// starting by HATHORIS_ +func (c *Config) FromEnv() error { + for _, line := range os.Environ() { + if strings.HasPrefix(line, "HATHORIS_") { + err := c.parseLine(line) + if err != nil { + return fmt.Errorf("error in environment (%q): %w", line, err) + } + } + } + return nil +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..f90d46e --- /dev/null +++ b/go.mod @@ -0,0 +1,32 @@ +module git.nemunai.re/nemunaire/hathoris + +go 1.21 + +require github.com/gin-gonic/gin v1.9.1 + +require ( + github.com/bytedance/sonic v1.9.1 // indirect + github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect + github.com/gabriel-vasile/mimetype v1.4.2 // indirect + github.com/gin-contrib/sse v0.1.0 // indirect + github.com/go-playground/locales v0.14.1 // indirect + github.com/go-playground/universal-translator v0.18.1 // indirect + github.com/go-playground/validator/v10 v10.14.0 // indirect + github.com/goccy/go-json v0.10.2 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/cpuid/v2 v2.2.4 // indirect + github.com/leodido/go-urn v1.2.4 // indirect + github.com/mattn/go-isatty v0.0.19 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pelletier/go-toml/v2 v2.0.8 // indirect + github.com/twitchyliquid64/golang-asm v0.15.1 // indirect + github.com/ugorji/go/codec v1.2.11 // indirect + golang.org/x/arch v0.3.0 // indirect + golang.org/x/crypto v0.9.0 // indirect + golang.org/x/net v0.10.0 // indirect + golang.org/x/sys v0.8.0 // indirect + golang.org/x/text v0.9.0 // indirect + google.golang.org/protobuf v1.30.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..1a77fa1 --- /dev/null +++ b/go.sum @@ -0,0 +1,86 @@ +github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM= +github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s= +github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U= +github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY= +github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams= +github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU= +github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA= +github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= +github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= +github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg= +github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js= +github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +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/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= +github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk= +github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q= +github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= +github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY= +github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +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.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= +github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= +golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= +golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= +golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g= +golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= +golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng= +google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +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/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= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= diff --git a/main.go b/main.go new file mode 100644 index 0000000..5de44c0 --- /dev/null +++ b/main.go @@ -0,0 +1,34 @@ +package main + +import ( + "log" + "os" + "os/signal" + "syscall" + + "git.nemunai.re/nemunaire/hathoris/config" + _ "git.nemunai.re/nemunaire/hathoris/sources/amp1_gpio" + _ "git.nemunai.re/nemunaire/hathoris/sources/mpv" +) + +var ( + Version = "custom-build" +) + +func main() { + cfg, err := config.Consolidated() + if err != nil { + log.Fatal("Unable to read configuration:", err) + } + + // Start app + a := NewApp(cfg) + go a.Start() + + quit := make(chan os.Signal, 1) + signal.Notify(quit, os.Interrupt, syscall.SIGTERM) + <-quit + log.Println("Stopping the service...") + a.Stop() + log.Println("Stopped") +} diff --git a/sources/amp1_gpio/source.go b/sources/amp1_gpio/source.go new file mode 100644 index 0000000..c7edf07 --- /dev/null +++ b/sources/amp1_gpio/source.go @@ -0,0 +1,73 @@ +package amp1gpio + +import ( + "bytes" + "io" + "log" + "os" + "path" + + "git.nemunai.re/nemunaire/hathoris/sources" +) + +type AMP1GPIOSource struct { + Path string +} + +const GPIODirectory = "/sys/class/gpio/gpio46/" + +func init() { + if _, err := os.Stat(GPIODirectory); err == nil { + sources.SoundSources["amp1"] = &1GPIOSource{ + Path: GPIODirectory, + } + } +} + +func (s *AMP1GPIOSource) GetName() string { + return "entrée analogique" +} + +func (s *AMP1GPIOSource) read() ([]byte, error) { + fd, err := os.Open(path.Join(s.Path, "value")) + if err != nil { + return nil, err + } + defer fd.Close() + + return io.ReadAll(fd) +} + +func (s *AMP1GPIOSource) IsActive() bool { + return s.IsEnabled() +} + +func (s *AMP1GPIOSource) IsEnabled() bool { + b, err := s.read() + if err != nil { + log.Println("Unable to get amp1 GPIO state:", err.Error()) + return false + } + + return bytes.Compare(b, []byte{'1'}) == 0 +} + +func (s *AMP1GPIOSource) write(value string) error { + fd, err := os.Create(path.Join(s.Path, "value")) + if err != nil { + return err + } + defer fd.Close() + + _, err = fd.Write([]byte(value)) + + return err +} + +func (s *AMP1GPIOSource) Enable() error { + return s.write("1") +} + +func (s *AMP1GPIOSource) Disable() error { + return s.write("0") +} diff --git a/sources/interfaces.go b/sources/interfaces.go new file mode 100644 index 0000000..95fb83e --- /dev/null +++ b/sources/interfaces.go @@ -0,0 +1,13 @@ +package sources + +import () + +var SoundSources = map[string]SoundSource{} + +type SoundSource interface { + GetName() string + IsActive() bool + IsEnabled() bool + Enable() error + Disable() error +} diff --git a/sources/mpv/source.go b/sources/mpv/source.go new file mode 100644 index 0000000..46a5a19 --- /dev/null +++ b/sources/mpv/source.go @@ -0,0 +1,69 @@ +package mpv + +import ( + "fmt" + "os/exec" + + "git.nemunai.re/nemunaire/hathoris/sources" +) + +type MPVSource struct { + process *exec.Cmd + Options []string + File string +} + +func init() { + sources.SoundSources["mpv"] = &MPVSource{ + Options: []string{"--no-video"}, + File: "https://mediaserv38.live-streams.nl:18030/stream", + } +} + +func (s *MPVSource) GetName() string { + return "Radio 1" +} + +func (s *MPVSource) IsActive() bool { + return s.process != nil +} + +func (s *MPVSource) IsEnabled() bool { + return s.process != nil +} + +func (s *MPVSource) Enable() (err error) { + if s.process != nil { + return fmt.Errorf("Already running") + } + + var opts []string + opts = append(opts, s.Options...) + opts = append(opts, s.File) + + s.process = exec.Command("mpv", opts...) + if err = s.process.Start(); err != nil { + return + } + + go func() { + err := s.process.Wait() + if err != nil { + s.process.Process.Kill() + } + + s.process = nil + }() + + return +} + +func (s *MPVSource) Disable() error { + if s.process != nil { + if s.process.Process != nil { + s.process.Process.Kill() + } + } + + return nil +}