add systemd integration (optional)

more log priority adjustments

more log priorities

adjust some log priorities

set autoflush on stderr so that logging to systemd's journal (via UNIX socket) is more real-time

drop WorkQueue (abandoned idea)

direct stderr to the journal

install sql/ into share

fix ExecStart directive name

declare systemd service as of type 'exec'

that is, considered running after fork() and execve()

add systemd sysusers config

more systemd: require config file, run as a separate user, install

cope with no $idler right after idle is done

might be undef'd by an event handler

keep $loop variable at closure reach

otherwise it can't be stopped from within the closure, and $mpd->loop
may be the thing from re-init-ed $mpd (after a reconnect)

add systemd service file

working re-connection on disconnection

it is not enough to cancel the idle future and then re-connect.

Net::Async::MPD is just not suited for such a scenario due to its
internal state not refrecting the loss of connection

so, upon disconnect, abandon the N:A:MPD instance and create a new one

rework event looping, allows for graceful (re-)connection to MPD

the MPD may be down, not yet started (possibly on another host, so no
way to avoid this via systemd service dependencies)

add TODO about tracking song play moment

add dist.ini and sample mpd-feeder.conf

fixup idle rework: add WorkQueue

whitespace

convert Feeder to unit-level class too

rework idling again, walking around Net::Async::MPD interface

thing is, that the ->noidle() call places readers on the mpd handle,
because it uses ->send(). this interferes with the expected protocol
flow like this:

idle() is called, a reader/parser is queued by ->send()
when noidle is called, it calls send(), which queues another reader/parser
MPD sees the 'noidle' command and responds with plain 'OK', which is
consumed by the readers queued by idle(). this by itself causes a crash
because the is no "result" and ->{changes} is invoked on undefined value

it the undef deref is fixed, the protocol still hangs, because of the
extra readers queued, which consumes the reply of the next command
issued (e.g. 'playlist')

the other thing that doesn't work is the link check in mpd-feeder. on
timer, it wants to break out of 'idle' waiting just to be sure that the
connection is alive. this also causes dereferencing of an undefined
value and protocol lock up.

so, instead, the idle/noidle is implemented half under-the-table.
idle is implemented via ordinary send(), and broken by a crude call to
mpd->{mpd_handle}->write(), breaking API. this serves two purposes.
first, the readers queued by send() see toe 'OK' resulting from noidle
and return empty result, which is handled by Feeder without crashing.
second, sending a low-level 'noidle' command via the connection handle
avoids queuing extra reader which would cause protocol hang.

the result is that periodic connection checks (leaving and re-entering
idle) work, idle events (which put MPD out of idle mode) are handled
outside of 'idleness' as they should be, asynchronous signals
(TERM, INT, etc.) work as expected outside of 'idleness'. happy camping
all around!

convert to unit-type class definition

periodically break out of idle mode to see if the connection to MPD is intact

it may be hanging if for example the local system was suspended. in
this situation mpd would detect the missing peer (us) when e.g. reporting
idle changes and close the tcp socket. later, the local system resumes
and the local tcp connection is still open and waiting for an idle result
forever

no warnings on undef usage when idle waiting results in no changes

this is normal when the idle mode is stopped with 'noidle'

move 'connect' method next to the 'disconnect' method

implement unwanted album list manipulation

do not crash when the playlist is cleared

the 'playlist' idle event returns no result in this case which lead to
an attempt to dereference undefined value

rework DB update using COPY and a PostgreSQL function for maximum speed

COPY is the most effective data loading mechanism, and using a function
reduces the number of requests to just one

drop "run" method which became a wrapper around prepare_to_wait_idle

subscribe to "close" event only once, after connecting to mpd

add list-unwanted-artists command

fix DB interaction from commands after DB split-out

a second HIP/INT signal causes a hard exit()

split out DB operations in a module

show command line upon re-exec (log_level=trace)

exit cleanly on SIGTERM and SIGINT

split command execution into App::MPD::Feeder::Command

avoids having dead code in RAM when the main loop is operating

turn on :utf8 everywhere with utf8::all

now that sources are declared and decoded as utf8, output needs to be
encoded

fix DB stats retrieval when no songs were queued recently

strangely one of the totals was getting undef and broke the division
perhaps the UNION is not working as expected?

fixup split of App::MPD::Feeder

move mail event loop to Feeder

split-out App::MPD::Feeder -- the main application module

move Options in a stand-alone module

show counts of available songs/albums/artist

for now in log_level=debug

connect to the DB early when in feeder mode

this way any problems in the connection will show at startup instead
of later when a new song needs to be queued

fix two instances of hanging open statements

when a cursor is exhausted with while (sth->fetch) {...} there is no
problem. Single row fetches, however need an explicit sth->finish or
the cursor remains open. this is not a big problem, but it is annoying
to see the warnings when the statement is reused (due to caching) or the
connection is shut down

fix filtering on album last queue time

joining on the full PK of albums table avoids multiple matches
and erroneous extra results

fix filling album information

some songs have Artist, some have AlbumArtist. mpd-feeder prefers the
later, but takes the former too

key artists by AlbumArtists

removes a favouring of compilation albums

perhaps en even better approach would be to consider both AlbumArtist
and Artist

include wanted playlist size when reporting its current state

dump configuration to STDERR on SIGUSR1

parse wanted playlist length as an integer

initially, log only errors

no need to always see details on command line/options parsing

re-exec on SIGHUP, picking up configuration file changes

my first approach was to just re-read the config, but could not make
the idle/playlist loop  behave. it gets stuck with responses getting
lost and eventually is disconnected my MPD due to timeout

re-exec works, but there is a (very small) chance of missing a database
update between disconnection and re-connection to MPD.

debug--

implement {add,del}-unwanted-artist commands

rename unwanted artist/album tables

do not print Pg errors, RaiseError=>1 is enough

postpone db update for when it is really needed

would help lower the load when massive changes to the db are made

the db will be updated when a new song needs to be queued, and until
that need arises the db may be changed again

the (not that big) delay for db update when new song is needed is not
a problem, because it is about keeping the playlist full -- not an
urgent need

make database update a synchronous operation

when someone calls for it, they rely that after the call to ->update_db
returns the database is fresh

there are tree callers - 'single', 'one-shot' and the database update
notification

more on-demand connections

rework command line handling - commands are commands, options are --options

also, initializa connections only if/when needed

Log::Any, proper idle looping

could not make Net::Async::MPD->idle work as expected, and the "manual"
method seems reliable

fix handling of database info

proper mpd connection initialization

make feeder->mpd accessible

declare used modules

added --skip-db-update option

skips initial database update

fix interval handling when finding suitable songs

fixed SQL param numbers

fixed database connection string

initial source import

option/config parsing works, perhaps the db interactions too