1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
package main
import (
"database/sql"
"fmt"
"os"
"path"
"path/filepath"
"strings"
"github.com/dhowden/tag"
_ "github.com/mattn/go-sqlite3"
"muhq.space/go/wrms/llog"
)
const DB_URL = "file:songs?mode=memory&cache=shared"
type LocalBackend struct {
musicDir string
db *sql.DB
}
func NewLocalBackend(musicDir string) *LocalBackend {
b := LocalBackend{musicDir: musicDir}
var err error
b.db, err = sql.Open("sqlite3", DB_URL)
if err != nil {
llog.Fatal("Opening in-memory db failed: %q", err)
}
sqlStmt := `
CREATE TABLE songs (
Uri text NOT NULL PRIMARY KEY,
Title text,
Artist text
);
`
_, err = b.db.Exec(sqlStmt)
if err != nil {
llog.Fatal("%q: %s", err, sqlStmt)
}
go b.findSongs()
return &b
}
func (_ *LocalBackend) OnSongFinished(*Song) {}
func (b *LocalBackend) insert(songs []*Song) {
llog.Debug("Inserting %d songs into local DB", len(songs))
tx, err := b.db.Begin()
if err != nil {
llog.Fatal("Starting insert transaction failed: %q", err)
}
stmt, err := tx.Prepare("INSERT INTO songs(Uri, Title, Artist) VALUES(?, ?, ?)")
if err != nil {
llog.Fatal("Preparing inser statement failed: %q", err)
}
defer stmt.Close()
for _, song := range songs {
_, err = stmt.Exec(song.Uri, song.Title, song.Artist)
if err != nil {
llog.Fatal("Executing insert statement failed: %q", err)
}
}
err = tx.Commit()
if err != nil {
llog.Fatal("Commiting insert transaction failed: %q", err)
}
}
func (b *LocalBackend) findSongs() {
llog.Debug("Starting song search under: %s", b.musicDir)
var songs []*Song
err := filepath.Walk(b.musicDir, func(p string, finfo os.FileInfo, err error) error {
if err != nil {
llog.Warning("error %v at path %s\n", err, p)
return err
}
if !finfo.Mode().IsRegular() {
return nil
}
ext := strings.ToLower(path.Ext(p))
for _, excluded := range []string{".png", ".jpg", ".txt", ".pdf", ".m3u"} {
if ext == excluded {
return nil
}
}
f, err := os.Open(p)
if err != nil {
llog.Warning("error %v opening file %s", err, p)
return err
}
defer f.Close()
m, err := tag.ReadFrom(f)
if err != nil {
llog.Warning("error reading tags from %s: %v", p, err)
// Contiune walking
return nil
}
s := NewSong(m.Title(), m.Artist(), "local", p)
songs = append(songs, &s)
return nil
})
if err != nil {
llog.Error("error walking the path %q: %v", b.musicDir, err)
}
b.insert(songs)
}
func (b *LocalBackend) Play(song *Song, player *Player) {
player.PlayUri("file://" + song.Uri)
}
func (b *LocalBackend) Search(keyword string) (results []Song) {
pattern := strings.ToLower(keyword)
query := fmt.Sprintf("SELECT * FROM songs WHERE Title LIKE '%%%s%%' OR Artist LIKE '%%%s%%'",
pattern, pattern)
llog.Debug("Searching in local DB using: %q", query)
rows, err := b.db.Query(query)
if err != nil {
llog.Error("Building search query %q failed: %q", query, err)
return
}
defer rows.Close()
for rows.Next() {
var uri string
var title string
var artist string
err = rows.Scan(&uri, &title, &artist)
if err != nil {
llog.Warning("Scanning query result failed: %q", err)
}
results = append(results, NewSong(title, artist, "local", uri))
}
err = rows.Err()
if err != nil {
llog.Error("Iterator returned error: %q", err)
}
llog.Debug("Local search returned %d results", len(results))
return results
}
|
