|
public static FromRetry ( |
||
| retry | The |
|
| return | ||
/// <summary>
/// Returns a new <see cref="CallSettings"/> with the given the expiration, merged with the (optional) original settings specified by <paramref name="settings"/>.
/// </summary>
/// <remarks>
/// If <paramref name="settings"/> is non-null and has retry-based timing, the returned settings will have the same timing, but with the specified
/// expiration. Otherwise, the returned settings will have a simple expiration.
/// </remarks>
/// <param name="settings">Existing settings. May be null, meaning there are currently no settings.</param>
/// <param name="expiration">Expiration to use in the returned settings, possibly as part of a retry. Must not be null.</param>
/// <returns></returns>
public static CallSettings WithExpiration(this CallSettings settings, Expiration expiration)
{
GaxPreconditions.CheckNotNull(expiration, nameof(expiration));
var retry = settings?.Timing?.Retry?.WithTotalExpiration(expiration);
var timing = retry == null?CallTiming.FromExpiration(expiration) : CallTiming.FromRetry(retry);
return(settings.WithCallTiming(timing));
}
/// <summary>
/// Returns a <see cref="CallSettings"/> which will have an effective deadline of at least <paramref name="deadline"/>.
/// If <paramref name="settings"/> already observes an earlier deadline (with respect to <paramref name="clock"/>),
/// or if <paramref name="deadline"/> is null, the original settings will be returned.
/// </summary>
/// <param name="settings">Existing settings. May be null, meaning there are currently no settings.</param>
/// <param name="deadline">Deadline to enforce. May be null, meaning there is no deadline to enforce.</param>
/// <param name="clock">The clock to use when computing deadlines. Must not be null.</param>
/// <returns>The call settings to use to observe the given deadline.</returns>
public static CallSettings WithEarlierDeadline(this CallSettings settings, DateTime?deadline, IClock clock)
{
GaxPreconditions.CheckNotNull(clock, nameof(clock));
// No deadline? Return what we already have.
if (deadline == null)
{
return(settings);
}
// No settings, or no timing in the settings? Create a simple expiration.
if (settings == null || settings.Timing == null)
{
// WithCallTiming (above) is an extension method - it's fine for settings to be null.
return(settings.WithCallTiming(CallTiming.FromDeadline(deadline.Value)));
}
// Okay, we have settings with a genuine timing component and a new deadline.
// We may still return the existing settings, if the new deadline is later than the existing
// one in the settings. But if the new deadline is earlier, we need to build new settings to accommodate
// it.
var timing = settings.Timing;
switch (timing.Type)
{
// For simple expirations, we can just replace one deadline for another simple one,
// if necessary.
case CallTimingType.Expiration:
return(timing.Expiration.CalculateDeadline(clock) < deadline.Value
? settings
: settings.WithCallTiming(CallTiming.FromDeadline(deadline.Value)));
// For retries, we may need to create a new RetrySettings with all the same other aspects,
// but a new deadline.
case CallTimingType.Retry:
if (timing.Retry.TotalExpiration.CalculateDeadline(clock) < deadline.Value)
{
return(settings);
}
var newTiming = CallTiming.FromRetry(timing.Retry.WithTotalExpiration(Expiration.FromDeadline(deadline.Value)));
return(settings.WithCallTiming(newTiming));
default:
throw new InvalidOperationException("Invalid call timing type");
}
}
