]> git.ktnx.net Git - mpd-feeder.git/blob - bin/mpd-feeder
be0fc2c073b7e2c0ba466442b535d05afa87dbbe
[mpd-feeder.git] / bin / mpd-feeder
1 #!/usr/bin/perl
2
3 use v5.32;
4
5 use Getopt::Long ();
6 use Log::Any qw($log);
7 use Log::Any::Adapter Stderr => log_level => 'trace';
8 use Object::Pad;
9 use Syntax::Keyword::Try;
10
11 class Options {
12     use Time::Duration qw(duration_exact);
13     use Time::Duration::Parse qw(parse_duration);
14     has $log_level           :reader = 'warn';
15     has $target_queue_length :reader = 10;
16     has $mpd_host            :reader = undef;
17     has $mpd_port            :reader = undef;
18     has $db_path             :reader = 'mpd-feeder';
19     has $db_user             :reader = undef;
20     has $db_password         :reader = undef;
21     has $min_album_interval  :reader = parse_duration('5h');
22     has $min_song_interval   :reader = parse_duration('13d');
23     has $min_artist_interval :reader = parse_duration('1h 15m');
24     has $skip_db_update      :reader = 0;
25
26     method parse_command_line {
27         Getopt::Long::GetOptions(
28             'log-level=s'               => \$log_level,
29             'skip-db-update!'           => \$skip_db_update,
30             'tql|target-queue-length=n' => \$target_queue_length,
31             'mpd-host=s'                => \$mpd_host,
32             'mpd-port=s'                => \$mpd_port,
33             'db-path=s'                 => \$db_path,
34             'db-user=s'                 => \$db_user,
35             'min-album-interval=s'      => sub {
36                 $min_album_interval = parse_duration(pop);
37             },
38             'min-sing-interval=s' => sub {
39                 $min_song_interval = parse_duration(pop);
40             },
41             'min-artist-interval=s' => sub {
42                 $min_artist_interval = parse_duration(pop);
43             },
44         ) or exit 1;
45     }
46
47     sub handle_config_option( $ini, $section, $option, $target_ref,
48         $converter = undef )
49     {
50         return undef unless exists $ini->{$section}{$option};
51
52         my $value = $ini->{$section}{$option};
53
54         $value = $converter->($value) if $converter;
55
56         $$target_ref = $value;
57     }
58
59     method dump {
60         say "[mpd-feeder]";
61         say "log_level = $log_level";
62         say "";
63         say "[mpd]";
64         say "host = " . ( $mpd_host // '' );
65         say "port = " . ( $mpd_port // '' );
66         say "target-queue-length = $target_queue_length";
67         say "";
68         say "[queue]";
69         say "target-length = $target_queue_length";
70         say "min-song-interval = " . duration_exact($min_song_interval);
71         say "min-album-interval = " . duration_exact($min_album_interval);
72         say "min-artist-interval = " . duration_exact($min_artist_interval);
73         say "";
74         say "[db]";
75         say "path = " .     ( $db_path     // '' );
76         say "user = " .     ( $db_user     // '' );
77         say "password = " . ( $db_password // '' );
78     }
79
80     method parse_config_file($path) {
81         use Config::INI::Reader;
82         my $ini = Config::INI::Reader->read_file($path);
83
84         handle_config_option( $ini => mpd => host => \$mpd_host );
85         handle_config_option( $ini => mpd => port => \$mpd_port );
86
87         handle_config_option( $ini => 'mpd-feeder' => log_level => \$log_level );
88
89         handle_config_option(
90             $ini => queue => 'target-length' => \$target_queue_length );
91         handle_config_option(
92             $ini => queue => 'min-song-interval' => \$min_song_interval,
93             \&parse_duration
94         );
95         handle_config_option(
96             $ini => queue => 'min-album-interval' => \$min_album_interval,
97             \&parse_duration
98         );
99         handle_config_option(
100             $ini => queue => 'min-artist-interval' => \$min_artist_interval,
101             \&parse_duration
102         );
103
104         handle_config_option( $ini => db => path     => \$db_path );
105         handle_config_option( $ini => db => user     => \$db_user );
106         handle_config_option( $ini => db => password => \$db_password );
107
108         # FIXME: complain about unknown sections/parameters
109     }
110 }
111
112 class Feeder {
113     has $opt :reader;
114     has $db;
115     has $db_generation;
116     has $db_needs_update = 1;
117     has $mpd :reader;
118
119 use constant DEFAULT_CONFIG_FILE => '/etc/mpd-feeder/mpd-feeder.conf';
120
121 use DBD::Pg;
122 use DBI;
123 use Log::Any qw($log);
124 use Net::Async::MPD;
125
126     ADJUST {
127         $opt = Options->new;
128
129         {
130             my $cfg_file;
131             Getopt::Long::Configure('pass_through');
132             Getopt::Long::GetOptions('cfg|config=s' => \$cfg_file);
133             Getopt::Long::Configure('no_pass_through');
134
135             $cfg_file //= DEFAULT_CONFIG_FILE if -e DEFAULT_CONFIG_FILE;
136
137             $opt->parse_config_file($cfg_file) if $cfg_file;
138         }
139
140         $opt->parse_command_line;
141
142         $db_needs_update = 0 if $opt->skip_db_update;
143
144         Log::Any::Adapter->set( Stderr => log_level => $opt->log_level );
145     }
146
147     method connect_mpd {
148         return if $mpd;
149
150         my %conn = ( auto_connect => 1 );
151         $conn{host} = $opt->mpd_host if $opt->mpd_host;
152         $conn{port} = $opt->mpd_port if $opt->mpd_port;
153
154         $mpd = Net::Async::MPD->new(%conn);
155     }
156
157     method connect_db {
158         return if $db;
159
160         $db = DBI->connect( "dbi:Pg:dbname=" . $opt->db_path,
161             $opt->db_user, $opt->db_password,
162             { RaiseError => 1, PrintError => 0, AutoCommit => 1 } );
163
164         $log->info( "Connected to database " . $opt->db_path );
165         $db_generation = $self->db_get_option('generation');
166         $log->debug("DB generation is $db_generation");
167         $self->update_db;
168     }
169
170     method db_get_option($name) {
171         my $sth = $db->prepare_cached("select $name from options");
172         $sth->execute;
173         my @result = $sth->fetchrow_array;
174
175         return $result[0];
176     }
177
178     method db_set_option( $name, $value ) {
179         my $sth = $db->prepare_cached("update options set $name = ?");
180         $sth->execute($value);
181     }
182
183     method db_store_song($song, $artist, $album) {
184         return unless length($song) and length($artist) and length($album);
185
186         $db->prepare_cached(
187             <<'SQL')->execute( $song, $artist, $album, $db_generation );
188 INSERT INTO songs(path, artist, album, generation)
189 VALUES($1, $2, $3, $4)
190 ON CONFLICT ON CONSTRAINT songs_pkey DO
191 UPDATE SET artist = $2
192          , album = $3
193          , generation = $4
194 SQL
195         $db->prepare_cached(<<'SQL')->execute( $artist, $album, $db_generation );
196 INSERT INTO albums(artist, album, generation)
197 VALUES($1, $2, $3)
198 ON CONFLICT ON CONSTRAINT albums_pkey DO
199 UPDATE SET generation = $3
200 SQL
201         $db->prepare_cached(<<'SQL')->execute( $artist, $db_generation );
202 INSERT INTO artists(artist, generation)
203 VALUES($1, $2)
204 ON CONFLICT ON CONSTRAINT artists_pkey DO
205 UPDATE SET generation = $2
206 SQL
207     }
208
209     method db_remove_stale_entries {
210         my $sth =
211             $db->prepare_cached('DELETE FROM songs WHERE generation <> ?');
212         $sth->execute($db_generation);
213         $log->debug( sprintf( "Deleted %d stale songs", $sth->rows ) );
214
215         $sth = $db->prepare_cached('DELETE FROM albums WHERE generation <> ?');
216         $sth->execute($db_generation);
217         $log->debug( sprintf( "Deleted %d stale albums", $sth->rows ) );
218
219         $sth =
220             $db->prepare_cached('DELETE FROM artists WHERE generation <> ?');
221         $sth->execute($db_generation);
222         $log->debug( sprintf( "Deleted %d stale artists", $sth->rows ) );
223     }
224
225     method db_note_song_qeued($item) {
226         $db->prepare_cached(
227             'UPDATE songs SET last_queued=current_timestamp WHERE path=?')
228             ->execute( $item->{song} );
229         $db->prepare_cached(
230             'UPDATE artists SET last_queued=CURRENT_TIMESTAMP WHERE artist=?')
231             ->execute( $item->{artist} );
232         $db->prepare_cached(
233             'UPDATE albums SET last_queued=CURRENT_TIMESTAMP WHERE artist=? AND album=?'
234         )->execute( $item->{artist}, $item->{album} );
235     }
236
237     method update_db($force = undef) {
238         if (!$db_needs_update and !$force) {
239             $log->debug("Skipping DB update");
240             return;
241         }
242
243         $log->info('Updating song database');
244         $self->connect_mpd;
245         $self->connect_db;
246
247         my $rows = $mpd->send('listallinfo')->get;
248         try {
249             $db->begin_work;
250
251             $db_generation++;
252
253             my $song_count;
254
255             foreach my $entry (@$rows) {
256                 next unless exists $entry->{file};
257                 $self->db_store_song( $entry->{file},
258                     $entry->{Artist}, $entry->{Album} );
259                 $song_count++;
260             }
261
262             $log->info("Updated data about $song_count songs");
263
264             $self->db_remove_stale_entries;
265
266             $self->db_set_option( generation => $db_generation );
267
268             $db->commit;
269
270             $db_needs_update = 0;
271         }
272         catch {
273             my $err = $@;
274
275             $db_generation--;
276
277             $db->rollback;
278
279             die $err;
280         }
281     }
282
283     method db_find_suitable_songs($num) {
284         $self->connect_db;
285         $self->update_db;
286
287         my @result;
288         my $sth = $db->prepare_cached(<<SQL);
289 SELECT s.path, s.artist, s.album
290 FROM songs s
291 JOIN artists ar ON ar.artist=s.artist
292 JOIN albums al ON al.album=s.album
293 WHERE (s.last_queued IS NULL OR s.last_queued < CURRENT_TIMESTAMP - (? || ' seconds')::interval)
294   AND (ar.last_queued IS NULL OR ar.last_queued < CURRENT_TIMESTAMP - (? || ' seconds')::interval)
295   AND (al.last_queued IS NULL OR al.last_queued < CURRENT_TIMESTAMP - (? || ' seconds')::interval)
296   AND NOT EXISTS (SELECT 1 FROM unwanted_artists uar WHERE uar.artist = s.artist)
297   AND NOT EXISTS (SELECT 1 FROM unwanted_albums  ual WHERE ual.album  = s.album)
298 ORDER BY random()
299 LIMIT ?
300 SQL
301         $sth->execute(
302             $opt->min_song_interval,
303             $opt->min_artist_interval,
304             $opt->min_album_interval,
305             $num,
306         );
307         while ( my @row = $sth->fetchrow_array ) {
308             push @result,
309                 { song => $row[0], artist => $row[1], album => $row[2] };
310         }
311
312         return @result;
313     }
314
315     method queue_songs($num = undef, $callback = undef) {
316         if (!defined $num) {
317             $self->connect_mpd;
318             $mpd->send('playlist')->on_done(
319                 sub {
320                     my $present = scalar @{ $_[0] };
321
322                     $log->notice("Playlist contains $present songs");
323                     if ( $present < $opt->target_queue_length ) {
324                         $self->queue_songs(
325                             $opt->target_queue_length - $present, $callback );
326                     }
327                     else {
328                         $callback->() if $callback;
329                     }
330                 }
331             );
332
333             return;
334         }
335
336         my @list = $self->db_find_suitable_songs($num);
337
338         die "Found no suitable songs" unless @list;
339
340         if ( @list < $num ) {
341             $log->warn(
342                 sprintf(
343                     'Found only %d suitable songs instead of %d',
344                     scalar(@list), $num
345                 )
346             );
347         }
348
349         $log->info("About to add $num songs to the playlist");
350
351         my @paths;
352         for my $song (@list) {
353             my $path = $song->{song};
354             $path =~ s/"/\\"/g;
355             push @paths, $path;
356         }
357
358         $log->debug( "Adding " . join( ', ', map {"«$_»"} @paths ) );
359         my @commands;
360         for (@paths) {
361             push @commands, [ add => "\"$_\"" ];
362         }
363         $self->connect_mpd;
364         my $f = $mpd->send( \@commands );
365         $f->on_fail( sub { die @_ } );
366         $f->on_done(
367             sub {
368                 warn $_ for @_;
369                 $self->db_note_song_qeued($_) for @list;
370                 $callback->(@_) if $callback;
371             }
372         );
373     }
374
375     method prepare_to_wait_idle {
376         $log->trace('declaring idle mode');
377         $mpd->send('idle database playlist')->on_done(
378             sub {
379                 warn $_ for @_;
380                 my $result = shift;
381
382                 if ( $result->{changed} eq 'database' ) {
383                     $db_needs_update = 1;
384                     $self->prepare_to_wait_idle;
385                 }
386                 elsif ( $result->{changed} eq 'playlist' ) {
387                     $self->queue_songs( undef,
388                         sub { $self->prepare_to_wait_idle } );
389                 }
390                 else {
391                     use JSON;
392                     $log->warn(
393                         "Unknown result from idle: " . to_json($result) );
394                     $self->prepare_to_wait_idle;
395                 }
396             }
397         );
398     }
399
400     method run {
401         $mpd->on(
402             close => sub {
403                 die "Connection to MPD lost";
404             }
405         );
406
407         $self->prepare_to_wait_idle;
408     }
409 }
410
411 my $feeder = Feeder->new();
412
413 sub usage {
414     die "Usage: mpd-feeder [option...] [command]\n";
415 }
416
417 if (@ARGV) {
418     usage if @ARGV > 1;
419
420     my $cmd = shift @ARGV;
421
422     if ($cmd eq 'dump-config') {
423         $feeder->opt->dump;
424         exit;
425     }
426 # FIXME: handle blacklist manipulation
427
428     if ( $cmd eq 'one-shot' ) {
429         $feeder->queue_songs(undef, sub { exit });
430         $feeder->mpd->loop->run;
431     }
432     elsif ( $cmd eq 'single' ) {
433         $feeder->queue_songs(1, sub { exit });
434         $feeder->mpd->loop->run;
435     }
436     else {
437         die "Unknown command '$cmd'";
438     }
439 }
440
441 $feeder->queue_songs( undef, sub { $feeder->run } );
442
443 $feeder->mpd->loop->run;