/// <inheritdoc />
public override BigQueryJob PollJobUntilCompleted(JobReference jobReference, GetJobOptions options = null, PollSettings pollSettings = null)
{
GaxPreconditions.CheckNotNull(jobReference, nameof(jobReference));
return(Polling.PollRepeatedly(ignoredDeadline => GetJob(jobReference, options),
job => job.State == JobState.Done,
Clock, Scheduler, pollSettings ?? s_defaultPollSettings, CancellationToken.None));
}
/// <summary>
/// Polls the operation until it is complete, returning the completed operation.
/// </summary>
/// <remarks>
/// <para>
/// If this object already represents a completed operation, it is returned with no further RPCs.
/// If <paramref name="metadataCallback"/> is non-null, the callback will be called with any metadata
/// present before the result is returned.
/// </para>
/// <para>
/// Each callback is performed synchronously: this method waits for the callback to complete before the operation is next polled.
/// This guarantees that for a single call, metadata callbacks will never occur in parallel.
/// </para>
/// </remarks>
/// <param name="pollSettings">The settings to use for repeated polling, or null
/// to use the default poll settings (poll once every 10 seconds, forever).</param>
/// <param name="callSettings">The call settings to apply on each call, or null for default settings.</param>
/// <param name="metadataCallback">The callback to invoke with the metadata from each poll operation, even if the metadata is null.</param>
/// <returns>The completed operation, which can then be checked for errors or a result.</returns>
public Operation <TResponse, TMetadata> PollUntilCompleted(
PollSettings pollSettings = null,
CallSettings callSettings = null,
Action <TMetadata> metadataCallback = null)
{
if (IsCompleted)
{
metadataCallback?.Invoke(Metadata);
return(this);
}
// We need to work out the effective timing so that we can truncate any deadline, but anything else
// that's in the effective call settings can be left to the normal merging process. In particular,
// we don't want to include the header mutation that adds the version header, as otherwise we'll end up
// including it twice.
var effectiveTiming = Client.GetEffectiveCallSettingsForGetOperation(callSettings)?.Timing;
callSettings = callSettings.WithCallTiming(effectiveTiming);
Func <DateTime?, Operation <TResponse, TMetadata> > pollAction =
deadline =>
{
var result = PollOnce(callSettings.WithEarlierDeadline(deadline, Client.Clock));
metadataCallback?.Invoke(result.Metadata);
return(result);
};
return(Polling.PollRepeatedly(
pollAction, o => o.IsCompleted,
Client.Clock, Client.Scheduler, pollSettings ?? Client.DefaultPollSettings ?? s_defaultPollSettings,
callSettings?.CancellationToken ?? CancellationToken.None));
}
/// <summary>
/// Polls the operation until it is complete, returning the completed operation.
/// </summary>
/// <remarks>
/// <para>
/// If this object already represents a completed operation, it is returned with no further RPCs.
/// If <paramref name="metadataCallback"/> is non-null, the callback will be called with any metadata
/// present before the result is returned.
/// </para>
/// <para>
/// Each callback is performed synchronously: this method waits for the callback to complete before the operation is next polled.
/// This guarantees that for a single call, metadata callbacks will never occur in parallel.
/// </para>
/// </remarks>
/// <param name="pollSettings">The settings to use for repeated polling, or null
/// to use the default poll settings (poll once every 10 seconds, forever).</param>
/// <param name="callSettings">The call settings to apply on each call, or null for default settings.</param>
/// <param name="metadataCallback">The callback to invoke with the metadata from each poll operation, even if the metadata is null.</param>
/// <returns>The completed operation, which can then be checked for errors or a result.</returns>
public Operation <TResponse, TMetadata> PollUntilCompleted(
PollSettings pollSettings = null,
CallSettings callSettings = null,
Action <TMetadata> metadataCallback = null)
{
if (IsCompleted)
{
metadataCallback?.Invoke(Metadata);
return(this);
}
callSettings = Client.GetEffectiveCallSettingsForGetOperation(callSettings);
Func <DateTime?, Operation <TResponse, TMetadata> > pollAction =
deadline =>
{
var result = PollOnce(callSettings.WithEarlierDeadline(deadline, Client.Clock));
metadataCallback?.Invoke(result.Metadata);
return(result);
};
return(Polling.PollRepeatedly(
pollAction, o => o.IsCompleted,
Client.Clock, Client.Scheduler, pollSettings ?? Client.DefaultPollSettings ?? s_defaultPollSettings,
callSettings?.CancellationToken ?? CancellationToken.None));
}
/// <summary>
/// Polls until this table contains at least the given number of rows. This should be used carefully, only where we know the table won't be huge.
/// </summary>
/// <remarks>
/// <para>
/// This method is designed to make integration tests more reliable: after an insert, data fetching (with queries or ListRows)
/// may not see the new data.
/// </para>
/// <para>
/// We've tried using the data in BigQueryTable.Resource.NumRows and BigQueryTable.Resource.StreamingBuffer, but they're not as reliable as
/// just reading the rows.
/// </para>
/// </remarks>
/// <param name="expectedRows">The number of rows expected.</param>
/// <param name="pollSettings">The poll settings to use, or null to use the defaults (poll once every 2 seconds, 30 second timeout)</param>
/// <returns>The actual number of rows in the table.</returns>
/// <exception cref="TimeoutException">The timeout specified in the poll settings elapsed before the streaming buffer became empty.</exception>
public static int PollUntilRowCountIsAtLeast(this BigQueryTable table, int expectedRows, PollSettings pollSettings = null) =>
Polling.PollRepeatedly(
ignoredDeadline => table.ListRows().Count(),
count => count >= expectedRows,
SystemClock.Instance,
SystemScheduler.Instance,
pollSettings ?? s_defaultStreamingBufferPollSettings,
CancellationToken.None);
/// <summary>
/// Polls the operation until it is complete, returning the completed operation.
/// </summary>
/// <remarks>
/// If this object already represents a completed operation, it is returned immediately,
/// with no further RPCs.
/// </remarks>
/// <param name="pollSettings">The settings to use for repeated polling, or null
/// to use the default poll settings (poll once every 10 seconds, forever).</param>
/// <param name="callSettings">The call settings to apply on each call, or null for default settings.</param>
/// <returns>The completed operation, which can then be checked for errors or a result.</returns>
public Operation <T> PollUntilCompleted(PollSettings pollSettings = null, CallSettings callSettings = null)
{
if (IsCompleted)
{
return(this);
}
// TODO: Use the deadline.
Func <DateTime?, Operation <T> > pollAction = deadline => PollOnce(callSettings);
return(Polling.PollRepeatedly(pollAction, o => o.IsCompleted, Client.Clock, Client.Scheduler, pollSettings ?? s_defaultPollSettings));
}
/// <summary>
/// Polls the operation until it is complete, returning the completed operation.
/// </summary>
/// <remarks>
/// If this object already represents a completed operation, it is returned immediately,
/// with no further RPCs.
/// </remarks>
/// <param name="pollSettings">The settings to use for repeated polling, or null
/// to use the default poll settings (poll once every 10 seconds, forever).</param>
/// <param name="callSettings">The call settings to apply on each call, or null for default settings.</param>
/// <returns>The completed operation, which can then be checked for errors or a result.</returns>
public Operation <T> PollUntilCompleted(PollSettings pollSettings = null, CallSettings callSettings = null)
{
if (IsCompleted)
{
return(this);
}
// TODO: Use the deadline and get a cancellation token from the effective call settings.
Func <DateTime?, Operation <T> > pollAction = deadline => PollOnce(callSettings);
return(Polling.PollRepeatedly(
pollAction, o => o.IsCompleted,
Client.Clock, Client.Scheduler, pollSettings ?? s_defaultPollSettings,
CancellationToken.None));
}
/// <summary>
/// Polls the operation until it is complete, returning the completed operation.
/// </summary>
/// <remarks>
/// If this object already represents a completed operation, it is returned immediately,
/// with no further RPCs.
/// </remarks>
/// <param name="pollSettings">The settings to use for repeated polling, or null
/// to use the default poll settings (poll once every 10 seconds, forever).</param>
/// <param name="callSettings">The call settings to apply on each call, or null for default settings.</param>
/// <returns>The completed operation, which can then be checked for errors or a result.</returns>
public Operation <T> PollUntilCompleted(PollSettings pollSettings = null, CallSettings callSettings = null)
{
if (IsCompleted)
{
return(this);
}
callSettings = Client.GetEffectiveCallSettingsForGetOperation(callSettings);
Func <DateTime?, Operation <T> > pollAction = deadline => PollOnce(callSettings.WithEarlierDeadline(deadline, Client.Clock));
return(Polling.PollRepeatedly(
pollAction, o => o.IsCompleted,
Client.Clock, Client.Scheduler, pollSettings ?? s_defaultPollSettings,
callSettings?.CancellationToken ?? CancellationToken.None));
}
internal int PollRepeatedly(PollSettings pollSettings, CancellationToken cancellationToken) => Polling.PollRepeatedly(Poll, IsPositive, Clock, Scheduler, pollSettings, cancellationToken);
/// <inheritdoc />
public override BigqueryQueryJob PollQueryUntilCompleted(JobReference jobReference, GetQueryResultsOptions options = null, PollSettings pollSettings = null)
{
GaxPreconditions.CheckNotNull(jobReference, nameof(jobReference));
return(Polling.PollRepeatedly(ignoredDeadline => GetQueryResults(jobReference, options),
job => job.Completed, Clock, Scheduler, pollSettings ?? s_defaultPollSettings));
}
