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