liquidsoap-2.3 replacement for on_leave()

[periode]

Hello,

I'm migrating our broadcasting script from 2.1.4 to 2.3.x-rc, and there's one feature that I can figure out.

I would like to send an HTTP request at the end of specific streams in a switch.

radio =
  switch(
    track_sensitive=false,
    [
      (morning_jingle, delay(180., jingles)),
      (morning_slot, morning),
      (afternoon_jingle, delay(180., jingles)),
      (afternoon_slot, afternoon),
      (evening_jingle, delay(180., jingles)),
      (evening_slot, evening),
      (night_jingle, delay(180., jingles)),
      (night_slot, night),
      ({true}, fallback_track)
    ]
  )

def request_rotate() =
    req =
      http.post(
        headers=[
          ("Content-Type", "application/x-www-form-urlencoded"),
          ("Authorization", "Bearer #{api_auth_key}")
        ],
        data="moment=#{!moment}",
        "localhost:#{station_port}/dial/rotate"
      )

    if
      req.status_code >= 400
    then
      log.important("failed to request rotation")
    end
end

morning.on_leave(request_rotate)
afternoon.on_leave(request_rotate)
evening.on_leave(request_rotate)
night.on_leave(request_rotate)

And each morning, afternoon, evening and night is a version of this:

morning_playlists =
  playlist(
    mode='normal',
    reload_mode='watch',
    loop=false,
    "#{rotation_dir}/morning/",
    check_next=log_next_metadata
  )
morning_playlists = append(morning_playlists, insert_jingles)

p =
  playlist(
    mode='randomize',
    reload_mode='watch',
    "#{selections_dir}/morning/",
    check_next=log_next_metadata
  )
p.on_track(signal_selection)

morning_selections = replaygain(p)
morning_selections =
  crossfade(fade_out=2., fade_in=2., duration=5., morning_selections)
morning_selections = rotate(weights=[1, 4], [jingles_morning, morning_selections])

morning = fallback.skip(morning_playlists, fallback=morning_selections)

However, the more recent version of LS have dropped on_leave()

At ./scripts/broadcaster.liq, line 132, char 0-7:
morning.on_leave(request_rotate)

Error 5: 
this value has no method `on_leave`
  Its type is source(audio=pcm('B), 'A)
.{
  buffered : () -> [string * float],
  clock : clock,
  duration : () -> float,
  elapsed : () -> float,
  fallible : bool,
  id : () -> string,
  is_active : () -> bool,
  is_ready : () -> bool,
  is_up : () -> bool,
  last_metadata : () -> [string * string]?,
  log : 
  {level : (() -> int?).{set : (int) -> unit}
  },
  on_metadata : ((([string * string]) -> unit)) -> unit,
  on_shutdown : ((() -> unit)) -> unit,
  on_track : ((([string * string]) -> unit)) -> unit,
  on_wake_up : ((() -> unit)) -> unit,
  remaining : () -> float,
  seek : (float) -> float,
  self_sync : () -> bool,
  skip : () -> unit,
  time : () -> float
}
where
  'A is a set of tracks to be muxed into a source and a set of internal tracks.

I've gone through the API docs and it looks like on_done() might be a good replacement, but it's not clear what playlist is finished means... If the playlist is interrupted by the end of the switch, does this count as done?

Otherwise, maybe the proper way to go about it would be to, instead of doing the request when handling the end of a given playlist, I should do the request on the first track of the following playlist (would essentially be the same behavior).

Thanks for your opinions!

[toots]

Hi,

I think that in this case, a transition is the best way to go. Transitions are functions: fun (old_source, new_source) -> .. passed in the same order as the list of (predicate, source).

Something like this:

def transition(old_source, new_source) =
  thread.run(request_rotate)
  sequence([old_source, new_source])
end

radio =
  switch(
    track_sensitive=false,
    transitions=[
      transition,
      transition,
      transition,
      transition,
      transition,
      transition,
      transition,
      transition,
      transition
    ],
    [
      (morning_jingle, delay(180., jingles)),
      (morning_slot, morning),
      (afternoon_jingle, delay(180., jingles)),
      (afternoon_slot, afternoon),
      (evening_jingle, delay(180., jingles)),
      (evening_slot, evening),
      (night_jingle, delay(180., jingles)),
      (night_slot, night),
      ({true}, fallback_track)
    ]
  )

[periode]

Nice, thanks for pointing me in the right way, I'll try it out!

[periode]

@toots

I'm almost there, but now I'm a bit confused about the way liquidsoap handles return types.

I have these functions:

def request_rotate(src) = 
    id = src.id
    print(id)
end

def transition(old_source, new_source) =
    thread.run(delay=1., {request_rotate(old_source)})
    sequence([old_source, new_source])
end

And i get this error:

At ./test.liq, line 42 char 16 - line 65 char 5:
    transitions=[
        transition,
...
        transition
    ],

Error 5: this value has type
  [(_.{id : _}, ...) -> _]
but it should be a subtype of
  [(source('A), ...) -> _]

How come the second to last statement thread.run(delay=1., {request_rotate(old_source)}) defines the return type, and not the following call to sequence([]) ?

If I replace the body of request_rotate with a simple call to print(src), the compile checks pass. But I thought that variable assignment was of type unit and therefore shouldn't affect the return type?

Thanks!

[toots]

This is a limitation with the typing system. Once you start calling the source's methods, it assumes all sources in the list must have the same methods.

The most simple solution is to give the typechecker a hint that you only need sources with no methods. Something like this:

def request_rotate(src) = 
    # Using source.id() prevents the typechecker from assuming that src has a id method
    id = source.id(src)
    print(id)
end

def transition(old_source, new_source) =
    thread.run(delay=1., {request_rotate(old_source)})
    
    # Tell sequence that all we need here is a list of sources, don't care about methods:
    sequence([(old_source:source), (new_source:source)])
end

[periode]

Got it, thanks!