func playlist(w http.ResponseWriter, r *http.Request) {
mpdClient, err := mpd.Dial("tcp", MPDSERVER)
if err != nil {
fmt.Printf("Error dialing")
}
songs, err := mpdClient.PlaylistInfo(-1, -1)
if err != nil {
fmt.Fprintf(w, "Error")
return
}
output := []Song{}
for _, song := range songs {
output = append(output, Song{song["Id"], song["Artist"], song["Title"]})
/*
for key, value := range song {
fmt.Fprintf(w, "%s: %s\n", key, value)
}
fmt.Fprintf(w, "-----\n")
*/
}
js, err := json.Marshal(output)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
w.Header().Set("Content-Type", "application/json")
w.Write(js)
defer mpdClient.Close()
}
//Updates the library
func (l *library) update() error {
var conn *mpd.Client
fmt.Println("Connecting to MPD")
conn, err := mpd.Dial("tcp", "127.0.0.1:6600")
if err != nil {
fmt.Println("Error: could not connect to MPD for lib update")
return errors.New("Could not connect to MPD!")
}
defer conn.Close()
_, err = conn.Update("")
if err != nil {
fmt.Println("Error: could not update library!")
return err
}
//Let the update happen
time.Sleep(2 * time.Second)
songs, err := conn.ListAllInfo("/")
if err != nil {
fmt.Println("Error: could not retrieve new library!")
return err
}
l.library = songs
return nil
}
func mpdConnect() *mpd.Client {
con, err := mpd.Dial("tcp", configuration.MPDConf.Host)
if err != nil {
glog.Error("mpdConnect error: ", err.Error())
}
return con
}
func (mpd *mpdClientComponent) connect() error {
var err error
mpd.client, err = gompd.Dial("tcp", mpd.url)
if err != nil {
mpd.connected = false
return err
}
mpd.connected = true
return nil
}
func (m MPDInstance) Render() (item modules.Item) {
mpdItem := MPDItem{Name: m.name, Markup: "pango"}
mpdFormatData := MPDFormatData{}
var client *go_mpd.Client
if c, err := go_mpd.Dial("tcp", m.host_name+":"+strconv.Itoa(m.port)); err != nil {
log.Error(err.Error())
return nil
} else {
client = c
}
defer func(client *go_mpd.Client) {
if err := client.Close(); err != nil {
log.Error("Failed to disconnect: " + err.Error())
}
}(client)
if attrs, err := client.Status(); err == nil {
if state, ok := attrs["state"]; ok {
mpdFormatData.State = state
} else {
log.Error("Failed to read state.")
return nil
}
} else {
log.Error("Failed to obtain status: " + err.Error())
return nil
}
if attrs, err := client.CurrentSong(); err != nil {
log.Error("Failed to obtain current song: " + err.Error())
return nil
} else {
obj := reflect.ValueOf(&mpdFormatData).Elem()
for key, val := range attrs {
if f := obj.FieldByName(key); f.IsValid() {
val = strings.TrimSpace(val)
f.Set(reflect.ValueOf(val))
}
}
}
buffer := bytes.Buffer{}
if err := m.template.Execute(&buffer, mpdFormatData); err != nil {
log.Error("Failed to render mpd template: " + err.Error())
return nil
} else {
mpdItem.Text = buffer.String()
}
item = mpdItem
return
}
func (s *Service) Enable() (err error) {
s.Mpd, err = mpd.Dial("tcp", "localhost:6600")
if err != nil {
return err
}
s.Subscribe("mpd/play", "", s.handleSimple(s.play))
s.Subscribe("mpd/pause", "", s.handleSimple(s.pause))
s.Subscribe("mpd/next", "", s.handleSimple(s.Mpd.Next))
s.Subscribe("mpd/prev", "", s.handleSimple(s.Mpd.Previous))
return nil
}
func play(w http.ResponseWriter, r *http.Request) {
mpdClient, err := mpd.Dial("tcp", MPDSERVER)
if err != nil {
fmt.Printf("Error dialing")
}
err = mpdClient.Play(-1)
if err != nil {
fmt.Fprintf(w, "Error play")
return
}
defer mpdClient.Close()
}
func Run(server string) int {
conn, err := mpd.Dial("tcp", server)
if err != nil {
log.Fatal(err)
return 1
}
defer conn.Close()
u := &ui.Ui{Title: "nmpas"}
c := &Client{Conn: conn, Ui: u}
go c.Run()
u.Run()
return 0
}
func add(w http.ResponseWriter, r *http.Request) {
url := r.FormValue("url")
mpdClient, err := mpd.Dial("tcp", MPDSERVER)
if err != nil {
fmt.Printf("Error dialing")
return
}
if url != "" {
err = mpdClient.Add(url)
if err != nil {
fmt.Fprintf(w, "Error adding %s", url)
return
}
fmt.Fprintf(w, "ok")
}
defer mpdClient.Close()
}
func main() {
cfg := MustParseCommandline()
client, err := mpd.Dial("tcp", fmt.Sprintf("%s:%d", cfg.Host, cfg.Port))
if err != nil {
log.Fatalf("Failed to connect to mpd: %v", err)
return
}
keepAlivePinger := make(chan bool)
// Make sure the mpd connection survives long timeouts:
go func() {
for range keepAlivePinger {
client.Ping()
time.Sleep(1 * time.Minute)
}
}()
// Close pinger and client on exit:
defer func() {
close(keepAlivePinger)
client.Close()
}()
if cfg.UpdateMoodDatabase {
if err := updateMoodDatabase(client, cfg); err != nil {
log.Fatalf("Failed to update the mood db: %v", err)
}
return
}
if err := CleanupCatlightLock(); err != nil {
log.Fatalf("Failed to clean up previous lock: %v", err)
return
}
// Monitor MPD events and sync moodbar appropiately.
Watcher(client, cfg)
}
//Create a new queue
func newLibrary() *library {
var conn *mpd.Client
fmt.Println("Connecting to MPD")
conn, err := mpd.Dial("tcp", "127.0.0.1:6600")
if err != nil {
fmt.Println("Error: could not connect to MPD, exiting")
os.Exit(1)
}
defer conn.Close()
songs, err := conn.ListAllInfo("/")
if err != nil {
fmt.Println("Error: could not connect to MPD, exiting")
os.Exit(1)
}
shuffle(songs)
return &library{
library: songs,
}
}
func main() {
conn, err := mpd.Dial("tcp", "127.0.0.1:6600")
if err != nil {
fmt.Println("Error: could not connect to MPD, exiting")
os.Exit(1)
}
defer conn.Close()
w, err := mpd.NewWatcher("tcp", "127.0.0.1:6600", "", "player")
if err != nil {
fmt.Println("Error: could not connect to MPD, exiting")
os.Exit(1)
}
defer w.Close()
h := newHub()
go h.run()
// Log errors.
go func() {
for err := range w.Error {
log.Println("Error:", err)
}
}()
//Control song transitions -- During this time, update the websockets
go func() {
var status mpd.Attrs
for _ = range w.Event {
status, err = conn.Status()
if err != nil {
//Connections seem to drop often, so reconnect when this happens
fmt.Println("Couldn't get current status! Error: " + err.Error())
conn.Close()
fmt.Println("Reconnecting...")
conn, err = mpd.Dial("tcp", "127.0.0.1:6600")
if err != nil {
fmt.Println("Error: could not connect to MPD, exiting")
os.Exit(1)
}
defer conn.Close()
status, err = conn.Status()
}
pos, _ := strconv.ParseFloat(status["elapsed"], 64)
fmt.Println(pos)
if pos == 0.000 {
//Stop us from getting into an infinite loop by waiting 25 ms
time.Sleep(25 * time.Millisecond)
//updateQueue <- &updateQueueMsg{Song: song["Title"], Artist: song["Artist"]}
conn.Pause(true)
//Wait 3 seconds then resume next song
time.Sleep(3000 * time.Millisecond)
conn.Pause(false)
song, err := conn.CurrentSong()
if err != nil {
fmt.Println("Couldn't get current song! Error: " + err.Error())
} else {
//Serialize and send info
msg := map[string]string{"cmd": "NP", "Title": song["Title"], "Artist": song["Artist"], "Album": song["Album"], "Cover": "/art/" + GetAlbumDir(song["file"])}
jsonMsg, _ := json.Marshal(msg)
h.broadcast <- []byte(jsonMsg)
}
}
}
}()
song, err := conn.CurrentSong()
if err != nil {
fmt.Println("No Song!")
} else {
fmt.Println(song["Title"])
}
songs, err := conn.ListAllInfo("/")
shuffle(songs)
subset := songs[:20]
//Searches for cover image
web.Get("/art/(.+)", getCover)
//Returns main page with custom selection of songs
web.Get("/", func(ctx *web.Context) string {
return getIndex(ctx, subset)
})
//Returns a raw song
web.Get("/song/(.+)", getSong)
//Returns the JSON info for the currently playing song
web.Get("/np", func(ctx *web.Context) string {
song, _ := conn.CurrentSong()
jsonMsg, _ := json.Marshal(song)
return string(jsonMsg)
})
//Handle the websocket
web.Websocket("/ws", websocket.Handler(func(ws *websocket.Conn) {
handleSocket(ws, h)
}))
web.Get("/library", func(ctx *web.Context) string {
jsonMsg, _ := json.Marshal(subset)
return string(jsonMsg)
})
web.Run("0.0.0.0:8080")
}