Request for review and comments

[mirikbb]

I have liquidsoap 2.3 installed and streaming is working well via icecast 2.4.4. As I have a big playlist and NOT streaming 24/7, I created the script with following logic:

• songs are played randomly
• send to icecast not only track and artist, but also album name
• every song already played is moved from playlist to backup list => when stream is stopped and restarted (next hour/day/week) it will not play already played songs. So despite several restarts of stream, each song will be played at the end only once
• when playlist will become empty, the streaming will stop

Even all is working as I designed, I am sure that something can be done better, fine tuned, more effective ...
For example:

• how fail safe is moving song from main playlist to backup
• how fail safe is removing the song from main playlist
• is the order of the steps OK => the song is removed from playlist when it starts to play. Maybe would it be better to remove it right after the play?
• is reloading of playlist really necessary?
• is behavior of the script fail safe from Ctrl+C or service termination? Can this be handled better/differently?
• I used process.run to execute sed command to remove song from playlist. Would "prefix tmp:" do the work? I couldn't make it work. I don't want to remove mp3 song, just its entry in main playlist.

Thanks a lot for any hint!

# Play playlist in randomize order
# Send to icecast not only song and artist, but also album name
# Move already played song to backup file
# If playlist is empty, replace it with backup

# File paths
playlist_file = "/home/user/Music/playlist_tst.m3u"
backup_file = "/home/user/Music/backup.m3u"

# Function to format and send metadata to icecast, including album
def set_metadata(m)
  # Extract artist, title, and album from the metadata
  title = m["title"]
  album = m["album"]

  # Create custom metadata string for Icecast
  custom_metadata = "#{title} (Album: #{album})"

  # Return updated metadata for Icecast
  [("title", custom_metadata)]
end

def log_song(m)
  played_song = m["filename"]
  file.write(append=true, data=played_song, backup_file)
  file.write(append=true, data="\n", backup_file)
end

#   Remove the played song from the playlist file
def remove_played_track(m)
  played_song = m["filename"]
  print(played_song)
  escaped_song = string.replace(pattern="/", (fun(_) -> "\\/"), played_song)
  print(escaped_song)
  process.run("sed -i --debug '/^#{escaped_song}$/d' #{playlist_file}")
end

# Load the playlist in randomize mode (shuffle the playlist each time it is loaded, and play it in this order for a whole round ("randomize" mode))
# Watch any changes in playlist and reload on change
main_playlist = playlist(loop=false, reload_mode="watch", mode="randomize", playlist_file)

# Attach new metadata
main_playlist = metadata.map(set_metadata, main_playlist)
main_playlist.on_track(log_song)
main_playlist.on_track(remove_played_track)

#Turn a source into an infaillible source by adding blank when the source is not available.
main_playlist = mksafe(main_playlist)

# Output the stream to Icecast with MP3 format
output.icecast(
  %mp3(bitrate=320, id3v2=true),
  fallible=true,
  host="my.server.local",
  port=8000,
  password="hackme",
  mount="/stream.mp3",
  name="my radio",
  description="My radio",
  genre="Electronic",
  url="http://my.server.local:8000/stream.mp3",
  main_playlist
)

[vitoyucepi]

Hi @mirikbb,
Does your script reload a playlist every time you remove a track from it? I haven't run the script, but I think sed triggers watch.
Also, your script will play the same songs because it doesn't check the contents of the backup file. You may want to use the playlog function for that. If you have to store the global state of the application, then some sort of database is required. In 2.3.0, sqlite support was added, but saving to a json file periodically will be fine.
The mksafe function will make the source infallible, so you don't need to mark output.icecast as fallible.