[FEATURE] Allow factory execution to prefer fail-safe, otherwise report error

[Tvde1]

Problem

FusionCache only activates failsafe when the factory throws or times out. If the factory returns any value, even an error-type value, FusionCache treats the operation as successful. This prevents using fail-safe with structured error-return types like Result<T>.

I wish that the factory can say "this operation failed, so I wish to trigger the fail-safe. But if there is no fail-safe, then return this value"

Solution

Provide an API that lets the factory explicitly mark the execution as failed after it has completed, while still returning a value. This should activate failsafe if a cached value exists, but still return the factory output if no failsafe value is available.

Alternatives

The alternative is to turn on fail-safe, and provide a generic "The factory has failed" error code when GetOrSetAsync has returned null.

Additional context

Add any other context or screenshots about the feature request here.

My scenario is as follows:

var result = await _cache.GetOrSetAsync<Result<List<SomeContent>>>(
    cacheKey,
    async (context, ct) =>
    {
        var factoryResult = await DoExpensiveCall(query, ct);

        if (factoryResult.ErrorCode != null)
        {
            // Here we want to fall back to failsafe if available
            context.PreferFailsafe();

            // We return the error so the user still knows what exactly went wrong (described in the Result<>.
            // This will also be the new fail-safe value (also for throttling)
            return factoryResult;
        }

        return factoryResult;
    },
    options =>
    {
        options.Duration = TimeSpan.FromMinutes(10);
        options.SetFailSafe(true, TimeSpan.FromHours(1));
    },
    token: cancellationToken);

[Tvde1]

Seems to be what the user in #275 wants, but did not perfectly describe.
Seems also slightly discussed in: #203

[Tvde1]

I think I have a working prototype.
Can you find anything that might go wrong with this approach?

Important! Failsafe must be enabled, otherwise factory will throw an error.

public static class ApiResultGuard
{
    public static async Task ExampleUse(IFusionCache cache, CancellationToken cancellationToken)
    {
        Task<ApiResult<int>> Factory(CancellationToken c) => Task.FromResult(ApiResult.Ok(42));
        
        var result = await cache.GetOrSetResultAsync<int>(
            "example_key",
            Factory,
            options =>
            {
                options.Duration = TimeSpan.FromHours(1);
            },
            errorOptions =>
            {
                errorOptions.Duration = TimeSpan.FromMinutes(1);
            },
            cancellationToken);
    }
    
    public static async Task<ApiResult<TApiResult>> GetOrSetResultAsync<TApiResult>(
        this IFusionCache cache,
        string key,
        Func<CancellationToken, Task<ApiResult<TApiResult>>> exampleFactory,
        Action<FusionCacheEntryOptions> setupAction,
        Action<FusionCacheEntryOptions> errorSetupAction,
        CancellationToken cancellationToken)
    {
        ApiResult<TApiResult> factoryResult = null;
        var failSafeDefaultValue = ApiResult.Fail<TApiResult>(ServiceError.NoFailsafe);

        var result = await cache.GetOrSetAsync<ApiResult<TApiResult>>(key,
            async (context, ct) =>
            {
                var result = await exampleFactory(ct);
                
                factoryResult = result;
                if (result.ErrorCode.HasValue)
                {
                    return context.Fail(result.ErrorCode.ToString());
                }

                return result;
            },
            failSafeDefaultValue: failSafeDefaultValue,
            setupAction,
            token: cancellationToken);

        if (result == failSafeDefaultValue)
        {
            await cache.SetAsync(key, factoryResult, options =>
            {
                // Sensible to not cache this in L2
                options.SkipDistributedCacheWrite = true;
                options.SkipBackplaneNotifications = true;
                errorSetupAction(options);
            }, token: token);
            return factoryResult;
        }

        return result;
    }
}

[jodydonetti]

Hi @Tvde1 , I think you can already do everything you want to do.

As you later noticed, you can use ctx.Fail(...) to signal an error without throwing an exception.

At the same time, you can check ctx.HasStaleValue to know if there is a stale value to use and, if so, use it with ctx.StaleValue.

By putting all of this together you can do something like this:

var result = await cache.GetOrSetAsync(
  key,
  async (ctx, ct) =>
  {
    var tmp = await exampleFactory(ct);

    // CHECK FOR ERROR
    if (tmp.ErrorCode.HasValue)
    {
      // CHECK FOR STALE VALUE (AS A FALLBACK)
      if (ctx.HasStaleValue)
      {
        // RETURN STALE VALUE
        return ctx.StaleValue.Value;
      }

      // ERROR + NO STALE VALUE -> FAIL
      return context.Fail(result.ErrorCode.ToString());
    }

    // ALL GOOD
    return tmp;
  }
);

Hope this helps, let me know.

[raisr]

Hi @jodydonetti, i have nearly the same use case but i can't really figure out how to solve this. I need access to the result object but in case of an error it should not be cached.

var result = await cache.GetOrSetAsync(
  key,
  async (ctx, ct) =>
  {
    var tmp = await exampleFactory(ct);

    // CHECK FOR ERROR
    if (tmp.ErrorCode.HasValue)
    {
      // CHECK FOR STALE VALUE (AS A FALLBACK)
      if (ctx.HasStaleValue)
      {
        // RETURN STALE VALUE
        return ctx.StaleValue.Value;
      }
      // ERROR + NO STALE VALUE -> RETURN WITHOUT CACHING
      context.Fail("Something went wrong.");
    }

    // ALL GOOD
    return tmp;
  }
);

[jodydonetti]

Hi @raisr

... but in case of an error it should not be cached.

The GetOrSet/Async() method must return something, that is its signature.

Think about it this way, look at this piece of code:

var value = cache.GetOrSet<int>("foo", _ => ...);

What should value be after this call?

So, the factory must:

• return something
• fail

So when you say "it should not be cached" there are 2 things I can see you doingyou can do:

• you can return a value, but tell FusionCache not to cache it (for example via ctx.Options.Duration = TimeSpan.Zero)
• you can fail, either via context.Fail("message") like you are already doing or by throwing an exception yourself

Hope this helps, let me know if I missed something.

[raisr]

@jodydonetti thank you. ctx.Options.Duration = TimeSpan.Zero was the missing piece. 👍