nemunaire/hathoris
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 11 Wiki Activity

Initial commit

Browse Source
This commit is contained in:
nemunaire 2023-11-12 21:25:57 +01:00
commit 5d0a210e6d
16 changed files with 998 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
.drone-manifest.yml Normal file
View File

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

116
.drone.yml Normal file
View File

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

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
/hathoris
/vendor
/ui/build
/ui/node_modules

14
api/routes.go Normal file
View File

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

84
api/sources.go Normal file
View File

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

289
api/volume.go Normal file
View File

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

69
app.go Normal file
View File

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

44
config/cli.go Normal file
View File

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

28
config/config.go Normal file
View File

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

21
config/env.go Normal file
View File

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

32
go.mod Normal file
View File

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

86
go.sum Normal file
View File

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

34
main.go Normal file
View File

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

73
sources/amp1_gpio/source.go Normal file
View File

@ -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"] = &AMP1GPIOSource{
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")
}

13
sources/interfaces.go Normal file
View File

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

69
sources/mpv/source.go Normal file
View File

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