Call function before execute request.dynamic and play it immediately

[rrolla]

Is it possible to call function right before dynamic request?

Version: Liquidsoap 2.2.5

At the inital start we don't prefetch any request, but if source1 is unavailable we create new dynamicRequest and play it immediately

Code example

source1 = mksafe(single('/mnt/music/source1.mp3'))
fallback = mksafe(single('/mnt/music/fallback.mp3'))

def dynamicRequest()
  response = callApi()
  if (response.success != true) then
      null()
  else
      relativePath = response.result

      fullPath = "annotate:source=\"music\":/mnt/music/#{relativePath}"
      createdRequest = (request.create(fullPath): request)
      if request.resolve(createdRequest) then
          createdRequest
      else
          null()
      end
  end
end

dynamicSource = request.dynamic(retry_delay=10.0, prefetch=0, dynamicRequest)

channel1Stream = fallback(track_sensitive=false, [source1, dynamicSource, fallback])

I was trying a lot of possible scripts, but always it skips dynamicSource and straight goes to fallback source

Thanks for powerful liquidsoap sofware

[vitoyucepi]

Hi @rrolla,

I think the state of the request.dynamic source without any requests in it is not ready. In case of a sudden source1 failure, the dynamicSource will have to spend some time to fetch the request anyway.

The fallback operator uses switch to select the source.

liquidsoap/src/libs/switches.liq

Lines 9 to 31 in 6acc8ab

	def fallback(
	~id=null(),
	~override="liq_transition_length",
	~replay_metadata=true,
	~track_sensitive=true,
	~transition_length=5.,
	~transitions=[],
	sources
	) =
	def add_condition(s) =
	({true}, s)
	end
	switch(
	id=id,
	override=override,
	replay_metadata=replay_metadata,
	transitions=transitions,
	track_sensitive=track_sensitive,
	transition_length=transition_length,
	list.map(add_condition, sources)
	)
	end

The switch operator in the order checks if the source is ready and the condition specified by the user is true.

[rrolla]

Thanks @vitoyucepi for your reply, is it possible to first fetch dynamicSource when source1 is not available then fallback to blank and then switch to dynamicSource?

[vitoyucepi]

Here's my vision of the feature, but I don't know if it's what you're looking for.

def custom_dynamic_request(~id=null(), ~retry_delay=10.,)
  id = string.id.default(default="custom_dynamic_request", id)

  request_fetch_enabled = ref(false)
  def enable_request_fetch()
    log.info("Enabling request fetching", label=id)
    request_fetch_enabled := true
  end
  def disable_request_fetch()
    log.info("Disabling request fetching", label=id)
    request_fetch_enabled := false
  end

  def fetch()
    log.important("Fetching new request", label=id)
    thread.run(disable_request_fetch, delay=retry_delay)
    log.important("Fetch simulation failed", label=id)
    null()
  end

  _request = request.dynamic(fetch, prefetch=0)

  thread.when(
    predicate.activates(request_fetch_enabled),
    {_request.fetch()},
    every=0.5,
    fast=false
  )

  def fetch_next()
    if not _request.is_ready() and not request_fetch_enabled() then
      enable_request_fetch()
    elsif _request.is_ready() and request_fetch_enabled() then
      disable_request_fetch()
    end
    true
  end

  _request.{
    check = fetch_next
  }
end

You can use it in the following way:

f = source.fail()
s = custom_dynamic_request()
b = blank()

r = switch(
  [
    ({true}, f),
    (s.check, s),
    ({true}, b)
  ],
  track_sensitive=false
)

Here's how it works

1. The switch operator will check if the user defined condition is true and source.is_ready() every frame.
2. f is always not ready.
3. b is always ready.
4. custom_dynamic_request is a custom function that returns the request.dynamic source and a check function that always returns true.
5. The fetch_next function checks if it should enable the next track fetch.
6. The request_fetch_enabled is responsible for saving the fetch state.
   If it's set to true, the single request would be fetched.
7. After fetching the new request, you should call disable_request_fetch to allow the next request to be fetched.

[rrolla]

Big thank you @vitoyucepi for your vision, it looks very promising