| Commit message (Collapse) | Author | Files | Lines |
|---|
|
It's been moved to its own repository at
https://github.com/fcuny/mpd-stats
Update the list of repositories managed by terraform.
|
|
The pre-commit hook for new lines reported and correct a number of
issues, so let's commit them now and after that we ca enable the hook
for the repository.
Change-Id: I5bb882d3c2cca870ef94301303f029acfb308740
Reviewed-on: https://cl.fcuny.net/c/world/+/592
Tested-by: CI
Reviewed-by: Franck Cuny <franck@fcuny.net>
|
|
Store the name of the subsystem in a constant, add some comments on
where to find the list.
|
|
|
|
Add a Makefile to install the binary in GOPATH and the unit file for the
service. When the binary is installed, systemd is reloaded and the
service is also started.
|
|
As I want the scrobbler to be started automatically when I log into my
session, the easiest way to do this is by having a systemd unit file
that I run for my own user.
The unit expects that the binary for the scrobbler is under my $GOPATH,
which is hard coded for now. We also ensure that the binary exists
before starting the unit.
We harness the service with a number of directives.
|
|
If the status of the player is "stop", we don't have a new song to
handle. In this case, if there's a current song, let's update the status
and clear our state.
Closes #1.
|
|
Add a column `playtime` to the records table to keep track of how long a
song was played.
With this information, in the future, we will be able to sum up how long
we listen to music, but also which songs were skipped.
|
|
The program needs two arguments: the mpd host and port, which can be
passed as flags (default is to use the local instance of mpd).
We store the database in `XDG_CONFIG_HOME/mpd-scrobbler`, and we create
the path if needed.
|
|
To compare the current attributes with the current record, we can use
the helper `EqualAttrs` which will tell us if we need to create a new
record or not.
|
|
|
|
When creating a scrobbler, we provide the path to the database. The
scrobbler then get a handler to the database.
When a new record is created, we persist it to the database using the
`save` function.
|
|
When we create a new record, let's capture when this was created.
|
|
We want to persist the records in a database, so we can extract
statistics and an history.
The module for the database is straightforward: it opens the database if
it exists and return an handler to it. If the database does not exists,
we create it and we create the only table we need (records).
|
|
|
|
Add a new function to create a scrobbler. The function takes care of
creating the mpd client.
Add a function to run the scrobbler, which takes care of creating a new
record when needed.
This will simplify the interface for the caller, as all they really care
about is: create the scrobbler, close it when we're done, and collect
songs information while we listen to our music.
|
|
|
|
Let's close both the watcher and the client, instead of leaking this
interface to the user.
|
|
|
|
When we receive an event from the player, we look if the song is
different from the previous one, and we create a new record if that's
the case. If the song is similar, there's nothing to do.
|
|
Define the type for a log record and add an helper function to create a
new record.
|
|
We create a module "mpd" to interact with our MPD instance. For now we
only have a single function to create a new client, which creates an
actual client for mpd (and we ping the instance every 30 seconds), and
a watcher to receive new events.
The tool "scrobbler" then wait for new events and display songs
information.
|
|
Describe what is being collected.
|
|
|
|
|
