1
0
dwelling-radio/internal/radio/icecast.go

224 lines
5.1 KiB
Go
Raw Permalink Normal View History

2022-03-08 01:17:24 +04:00
package radio
import (
"bytes"
"dwelling-radio/pkg/watcher"
2022-03-08 01:17:24 +04:00
"encoding/json"
"io"
2022-03-08 01:17:24 +04:00
"net/http"
"os"
2022-04-01 20:44:32 +04:00
"sync"
"syscall"
2022-03-08 01:17:24 +04:00
"time"
"github.com/pkg/errors"
2022-03-08 01:17:24 +04:00
)
2022-04-02 04:29:23 +04:00
const (
IcecastPlaylistDateFormat = "02/Jan/2006:15:04:05 -0700"
SongTimeFormat = "2006 15:04-0700"
bufferSizePerLine = 320
2022-04-02 04:29:23 +04:00
)
var (
currentlyPlaying Song
lastPlayedCache []Song
lastPlayedCacheMutex sync.Mutex
)
2022-03-08 01:17:24 +04:00
type IcecastStatusDTO struct {
Icestats struct {
ServerStartISO8601 string `json:"server_start_iso8601"`
ServerStartDate string `json:"server_start"`
Source struct {
Artist string `json:"artist"`
Title string `json:"title"`
ListenerPeak int `json:"listener_peak"`
Listeners int `json:"listeners"`
} `json:"source"`
} `json:"icestats"`
}
func (is *IcecastStatusDTO) SongName() string {
return is.Icestats.Source.Artist + " - " + is.Icestats.Source.Title
}
2022-03-08 01:17:24 +04:00
type IcecastStatus struct {
ServerStartISO8601 string `json:"server_start_iso8601"`
2022-03-31 02:16:15 +04:00
ServerStartDate string `json:"server_start_date"`
2022-03-08 01:17:24 +04:00
SongName string `json:"song"`
ListenerPeak int `json:"listener_peak"`
Listeners int `json:"listeners"`
}
type Song struct {
Time string `json:"time"`
Listeners string `json:"listeners"`
Song string `json:"song"`
2022-03-08 01:17:24 +04:00
}
func IcecastGetStatus(icecastURL string) (*IcecastStatus, error) {
resp, err := http.Get(icecastURL)
if err != nil {
return &IcecastStatus{}, err
2022-03-08 01:17:24 +04:00
}
iceStatDTO := &IcecastStatusDTO{}
if err := json.NewDecoder(resp.Body).Decode(iceStatDTO); err != nil {
return &IcecastStatus{}, err
2022-03-08 01:17:24 +04:00
}
return &IcecastStatus{
2022-03-08 01:17:24 +04:00
ServerStartISO8601: iceStatDTO.Icestats.ServerStartISO8601,
ServerStartDate: iceStatDTO.Icestats.ServerStartDate,
SongName: iceStatDTO.SongName(),
2022-03-08 01:17:24 +04:00
ListenerPeak: iceStatDTO.Icestats.Source.ListenerPeak,
Listeners: iceStatDTO.Icestats.Source.Listeners,
}, nil
2022-03-08 01:17:24 +04:00
}
2023-03-12 21:31:18 +04:00
func IcecastLastSongs(playlistPath string) ([]Song, error) {
lastPlayedCacheMutex.Lock()
defer lastPlayedCacheMutex.Unlock()
if lpcLen := len(lastPlayedCache); lpcLen > 0 {
2023-03-12 21:31:18 +04:00
ret := make([]Song, 0, lpcLen)
ret = append(ret, lastPlayedCache...)
return ret, nil
}
return nil, nil
}
func IcecastLastSong(playlistPath string) (*Song, error) {
lastPlayedCacheMutex.Lock()
defer lastPlayedCacheMutex.Unlock()
if lpcLen := len(lastPlayedCache); lpcLen > 0 {
return &lastPlayedCache[lpcLen-1], nil
}
return nil, nil
}
func icecastLastPlayedSongs(playlistPath string, n int) ([]Song, error) {
var buf []byte
var offset int64 = 0
var bufferSize int64 = int64(n) * bufferSizePerLine
2022-03-08 01:17:24 +04:00
playlist, err := os.Open(playlistPath)
if err != nil {
return nil, err
}
defer playlist.Close()
2022-03-08 01:17:24 +04:00
playlist_stat, _ := playlist.Stat()
if playlist_stat.Size() == 0 {
return nil, nil
2022-03-08 01:17:24 +04:00
}
if playlist_stat.Size() < bufferSize {
buf = make([]byte, playlist_stat.Size())
} else {
buf = make([]byte, bufferSize)
offset = playlist_stat.Size() - bufferSize
}
_, err = playlist.ReadAt(buf, offset)
if err != nil && err != io.EOF {
return nil, err
}
lines := bytes.Split(buf, []byte("\n"))
if len(lines) < 2 {
return nil, nil
}
lines = lines[:len(lines)-1]
if len(lines) > n {
lines = lines[len(lines)-n:]
}
2023-03-12 21:31:18 +04:00
songs := make([]Song, 0, len(lines))
for _, line := range lines {
fields := bytes.Split(line, []byte("|"))
tim, _ := time.Parse(IcecastPlaylistDateFormat, string(fields[0]))
songs = append(songs, Song{
Time: tim.Format(SongTimeFormat),
Listeners: string(fields[2]),
Song: string(fields[3])})
}
return songs, nil
2022-03-08 01:17:24 +04:00
}
type PlaylistLogWatcher struct {
watcher *watcher.InotifyWatcher
changed chan uint32
}
func NewPlaylistLogWatcher() *PlaylistLogWatcher {
return &PlaylistLogWatcher{changed: make(chan uint32)}
}
func (pw *PlaylistLogWatcher) Watch(playlistPath string, n int) (err error) {
if pw.watcher != nil {
pw.watcher.Close()
}
pw.watcher, err = watcher.NewInotifyWatcher()
if err != nil {
return errors.Wrap(err, "cannot instantiate inotify watcher")
}
err = pw.watcher.AddWatch(playlistPath, watcher.ModIgnMask)
if err != nil {
return errors.Wrap(err, "cannot set a playlist to watch")
}
pw.watcher.WatchForMask(pw.changed, watcher.ModIgnMask)
lastPlayedCache = make([]Song, 0, n)
2023-03-12 21:31:18 +04:00
go func() {
for {
select {
case mask := <-pw.changed:
if mask&syscall.IN_MODIFY > 0 {
2023-03-12 21:31:18 +04:00
lastPlayedCacheMutex.Lock()
if songs, err := icecastLastPlayedSongs(playlistPath, 1); err == nil && len(songs) > 0 {
2023-03-13 00:04:34 +04:00
CheckAndUpdateMostListenedSong(songs[0], currentlyPlaying)
if currentlyPlaying.Time == "" {
currentlyPlaying = songs[0]
} else {
currentlyPlaying.Listeners = songs[0].Listeners
if len(lastPlayedCache) == n {
lastPlayedCache = append(lastPlayedCache[1:], currentlyPlaying)
} else {
lastPlayedCache = append(lastPlayedCache, currentlyPlaying)
}
currentlyPlaying = songs[0]
}
}
2023-03-12 21:31:18 +04:00
lastPlayedCacheMutex.Unlock()
} else if mask&syscall.IN_IGNORED > 0 {
pw.Close()
pw.Watch(playlistPath, n)
return
}
}
}
}()
return nil
}
func (pw *PlaylistLogWatcher) Close() {
pw.watcher.Close()
}