feat: Initial commit

Author: Nierot

Makefile

@@ -0,0 +1,5 @@
+run:
+	go run .
+
+dev: 
+	air

config.toml

@@ -0,0 +1,6 @@
+[spotify]
+url = "http://aether:24879"
+ws = "aether:24879"
+
+[fallback]
+playlist = "spotify:playlist:3vleaMH00xMCNXOWHsqm73"

go.mod

@@ -0,0 +1,58 @@
+module github.com/ODDInvictus/aether
+
+go 1.21.1
+
+require (
+	github.com/bytedance/sonic v1.10.2 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/faiface/beep v1.1.0 // indirect
+	github.com/fatih/color v1.15.0 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/gin-gonic/gin v1.9.1 // 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.15.5 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/gorilla/websocket v1.5.0 // indirect
+	github.com/hajimehoshi/oto v0.7.1 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // 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.1.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rjeczalik/notify v0.9.3 // indirect
+	github.com/sagikazarmark/locafero v0.3.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.10.0 // indirect
+	github.com/spf13/cast v1.5.1 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/spf13/viper v1.17.0 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.9.0 // indirect
+	golang.org/x/arch v0.5.0 // indirect
+	golang.org/x/crypto v0.14.0 // indirect
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
+	golang.org/x/image v0.0.0-20190802002840-cff245a6509b // indirect
+	golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028 // indirect
+	golang.org/x/net v0.17.0 // indirect
+	golang.org/x/sys v0.13.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,87 @@
+package http
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/ODDInvictus/aether/logger"
+	"github.com/ODDInvictus/aether/spotify"
+	"github.com/gin-gonic/gin"
+)
+
+var r *gin.Engine
+
+func Init() *gin.Engine {
+	r = gin.Default()
+
+	r.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
+		return fmt.Sprintf("[%s] %s - \"%s %s %s %d %s \"%s\" %s\"\n",
+			param.TimeStamp.Format(time.RFC3339),
+			param.ClientIP,
+			param.Method,
+			param.Path,
+			param.Request.Proto,
+			param.StatusCode,
+			param.Latency,
+			param.Request.UserAgent(),
+			param.ErrorMessage,
+		)
+	}))
+
+	r.Use(gin.Recovery())
+
+
+	apiRoutes()
+
+	return r
+}
+
+func apiRoutes() {
+	r.GET("/hello", func (c *gin.Context) {
+		c.JSON(200, gin.H{
+			"message": "World!",
+		})
+	})
+
+	r.GET("/state", func (c *gin.Context) {
+		state, err := spotify.Current()
+
+		if err != nil {
+			c.JSON(500, gin.H{
+				"message": fmt.Sprint(err),
+			})
+		}
+
+		logger.Verbose(fmt.Sprint(state))
+
+		c.JSON(200, gin.H{
+			"state": state,
+		})
+	})
+
+	r.POST("/playlist/play", func (c *gin.Context) {
+		var params PlaylistPlay
+
+		if c.ShouldBind(&params) == nil {
+			ok, err := spotify.Load(params.SpotifyID, true, true)
+
+			if !ok {
+				c.JSON(500, gin.H{
+					"message": fmt.Sprint(err),
+				})
+			}
+
+			c.JSON(200, gin.H{
+				"message": "Success",
+			})
+		} else {
+			c.JSON(400, gin.H{
+				"message": "Invalid playlist id",
+			})
+		}
+	})
+
+	r.POST("/skip", func (c *gin.Context) {
+		spotify.Next()
+	})
+}

http/http.go

@@ -0,0 +1,5 @@
+package http
+
+type PlaylistPlay struct {
+	SpotifyID string `form:"spotify_id"`
+}

http/types.go

@@ -0,0 +1,40 @@
+package logger
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/fatih/color"
+)
+
+var debug bool
+
+func Debug (b bool) {
+	Log("Setting debug level to " + strconv.FormatBool(b))
+	debug = b
+}
+
+func Warn(stmt string) {
+	if !debug {
+		return
+	}
+
+	color.Yellow("[%s] [Wrn] %s\n", time.Now().Format(time.RFC3339), stmt)
+}
+
+func Err(stmt string, err error) {
+	color.Red("[%s] [Err] %s\n", time.Now().Format(time.RFC3339), stmt)
+	panic(err)
+}
+
+func Log(stmt string) {
+	color.Blue("[%s] [Log] %s\n", time.Now().Format(time.RFC3339), stmt)
+}
+
+func Verbose(stmt string) {
+	if !debug {
+		return
+	}
+
+	color.Magenta("[%s] [Ver] %s\n", time.Now().Format(time.RFC3339), stmt)
+}

logger/log.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"github.com/ODDInvictus/aether/http"
+	"github.com/ODDInvictus/aether/logger"
+	"github.com/ODDInvictus/aether/spotify"
+	"github.com/ODDInvictus/aether/utils"
+)
+
+var spotifyState spotify.SpotifyPlayer
+
+func main() {
+	logger.Log("Starting the Aether")
+	logger.Debug(true)
+	utils.LoadConfig()
+	utils.InitConnectionStatus()
+	
+	spotify.Init(false)
+	go spotify.ListenToEvents(&spotifyState)
+
+	router := http.Init()
+	router.Run()
+}

main.go

@@ -0,0 +1,128 @@
+package spotify
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"os/signal"
+	"strconv"
+	"time"
+
+	"github.com/ODDInvictus/aether/logger"
+	"github.com/gorilla/websocket"
+	"github.com/spf13/viper"
+)
+
+func ListenToEvents(state *SpotifyPlayer) {
+	Log("Listening to player events")
+
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	u := url.URL{Scheme: "ws", Host: viper.GetString("spotify.ws"), Path: "/events"}
+
+	conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
+
+	if err != nil {
+		logger.Err("failed to connect to websocket", err)
+	}
+
+	defer conn.Close()
+
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for {
+			_, message, err := conn.ReadMessage()
+			if err != nil {
+				panic("failed to read msg")
+			}
+
+			var res map[string]interface{}
+
+			err = json.Unmarshal(message, &res)
+
+			if err != nil {
+				continue
+			}
+
+			Log(fmt.Sprint(res["event"]))
+
+			switch res["event"] {
+			case "contextChanged":
+				state.contextUri = fmt.Sprint(res["uri"])
+			case "trackChanged":
+				state.uri = fmt.Sprint(res["uri"])
+			case "playbackEnded":
+				state.paused = true
+				state.trackTime = 0
+			case "playbackPaused":
+				state.paused = true
+				state.trackTime = int64(res["trackTime"].(float64))
+			case "playbackResumed":
+				state.paused = false
+				state.trackTime = int64(res["trackTime"].(float64))
+			case "playbackFailed":
+				state.paused = true
+				state.trackTime = 0
+			case "trackSeeked":
+				state.trackTime = int64(res["trackTime"].(float64))
+			case "metadataAvailable":
+				track := Track{}
+
+				jsonString, _ := json.Marshal(res["track"])
+				json.Unmarshal(jsonString, &track)
+
+				state.metadata = track
+			case "playbackHaltStateChanged":
+				x, err := strconv.ParseBool(fmt.Sprint(res["halted"]))
+				
+				if err != nil {
+					state.paused = true
+				} else {
+					state.paused = x
+				}
+				
+				state.trackTime = int64(res["trackTime"].(float64))
+			case "panic":
+				Log("Spotify failed, restarting song")
+				PlayPause()
+				PlayPause()
+				// Load(viper.GetString("fallback.playlist"), true, true)
+			}
+		}
+	}()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-done:
+			return
+		case t := <-ticker.C:
+			err := conn.WriteMessage(websocket.TextMessage, []byte(t.String()))
+			if err != nil {
+				logger.Err("write:", err)
+				return
+			}
+		case <-interrupt:
+			Log("closing connection...")
+
+			// Cleanly close the connection by sending a close message and then
+			// waiting (with timeout) for the server to close the connection.
+			err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+			if err != nil {
+				logger.Err("write close:", err)
+				return
+			}
+			select {
+			case <-done:
+			case <-time.After(time.Second):
+			}
+			return
+		}
+	}
+}