public void IdempotentCheckOnMutateRowRequest()
{
var setCell =
Mutations.SetCell("abc", "cq1", "value", new BigtableVersion(-1));
var deleteFromColumn =
Mutations.DeleteFromColumn("abc", "def", new BigtableVersionRange(-1, -1));
var request = new MutateRowRequest
{
Mutations =
{
Mutations.DeleteFromRow(),
setCell,
deleteFromColumn,
Mutations.DeleteFromFamily("abc")
}
};
Assert.True(request.IsIdempotent());
deleteFromColumn.DeleteFromColumn.TimeRange.StartTimestampMicros = -1;
deleteFromColumn.DeleteFromColumn.TimeRange.EndTimestampMicros = -1;
Assert.True(request.IsIdempotent());
setCell.SetCell.TimestampMicros = -1;
Assert.False(request.IsIdempotent());
}
public async Task RetryAfterTotalExpiration()
{
var settings = new BigtableServiceApiSettings();
// Don't allow for any time to retry.
settings.MutateRowsSettings = CallSettings.FromExpiration(Expiration.FromTimeout(TimeSpan.Zero));
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded),
Utilities.CreateMutateRowsResponseEntry(2, Code.Ok)
},
entriesForRetryStreams: new[]
{
// 1st retry response entries
new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) }
},
settings: settings);
var exception = await Assert.ThrowsAsync <RpcException>(() => client.MutateRowsAsync(request));
Assert.Equal(StatusCode.DeadlineExceeded, exception.StatusCode);
}
public async Task CheckAndMutateRow_Validate_Mutations()
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
null,
null);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new Mutation[0],
new Mutation[0]);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new Mutation[] { null },
new[] { Mutations.DeleteFromRow() },
callTrueMutationsOnlyOverload : false);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new Mutation[] { null },
callTrueMutationsOnlyOverload : false);
}
public async Task CheckAndMutateRow_Validate_RowKey()
{
var client = new TestBigtableClient();
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
new byte[0],
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
ByteString.Empty,
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
public async Task RetryBeforeTotalExpiration()
{
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded),
Utilities.CreateMutateRowsResponseEntry(2, Code.Ok)
},
entriesForRetryStreams: new[]
{
null, // A null entry will throw an Unavailable RpcException
// 2nd retry response entries
new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) }
});
await client.MutateRowsAsync(request);
}
public void DeleteFromRow()
{
var mutation = Mutations.DeleteFromRow();
Assert.NotNull(mutation.DeleteFromRow);
Assert.True(mutation.IsIdempotent());
}
public void CreateEntry()
{
var entry = Mutations.CreateEntry("abc", Mutations.DeleteFromRow());
Assert.Equal("abc", entry.RowKey.ToStringUtf8());
Assert.Equal(1, entry.Mutations.Count);
Assert.NotNull(entry.Mutations[0].DeleteFromRow);
}
public async Task CheckAndMutateRow_Validate_TableName()
{
await CheckAndMutateRow_ValidateArguments <ArgumentNullException>(
null,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
protected override async Task DeleteAsync(SnapshotMetadata metadata)
{
await _bigtableClient.MutateRowAsync(
_tableName,
GetRowKey(metadata.PersistenceId, metadata.SequenceNr),
new List <Mutation> {
Mutations.DeleteFromRow()
}).ConfigureAwait(false);
}
public async Task CheckAndMutateRow_Valid_Request()
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <RequestMadeException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
public async Task CheckAndMutateRow_Validate_RowKey(BigtableByteString rowKey)
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
rowKey,
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
public async Task CheckAndMutateRow_Valid_Request()
{
var client = new TestBigtableClient();
var tableName = new TableName("project", "instance", "table");
// NotImplementedException means it got through the normal validations and tried to actually
// make the request on the TestBigtableClient.
await CheckAndMutateRow_ValidateArguments <NotImplementedException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
public async Task SimpleRetry()
{
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded),
Utilities.CreateMutateRowsResponseEntry(2, Code.Ok)
},
entriesForRetryStreams: new[]
{
// 1st retry response entries
new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) }
});
var entries = (await client.MutateRowsAsync(request)).Entries.OrderBy(e => e.Index).ToList();
Assert.Equal(3, entries.Count);
var entry = entries[0];
Assert.Equal(0, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[1];
Assert.Equal(1, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[2];
Assert.Equal(2, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
}
public static void DeleteRows(string tableName, RowRange rowRange)
{
var bigtableClient = BigtableClient.Create();
var stream = bigtableClient.ReadRows(Google.Cloud.Bigtable.Common.V2.TableName.Parse(tableName), RowSet.FromRowRanges(rowRange));
var deleteRows = new List <MutateRowsRequest.Types.Entry>();
using (var enumerator = stream.GetEnumerator())
{
while (enumerator.MoveNext().GetAwaiter().GetResult())
{
deleteRows.Add(Mutations.CreateEntry(enumerator.Current.Key, Mutations.DeleteFromRow()));
}
}
if (deleteRows.Any())
{
bigtableClient.MutateRows(Google.Cloud.Bigtable.Common.V2.TableName.Parse(tableName), deleteRows);
}
}
protected void DeleteRows(string tableName, string pid)
{
var rowRange = RowRange.Closed(new BigtableByteString($"{pid}"), new BigtableByteString($"{pid}~"));
var bigtableClient = BigtableClient.Create();
var stream = bigtableClient.ReadRows(TableName.Parse(tableName), RowSet.FromRowRanges(rowRange));
var deleteRows = new List <MutateRowsRequest.Types.Entry>();
using (var enumerator = stream.GetEnumerator())
{
while (enumerator.MoveNext().GetAwaiter().GetResult())
{
deleteRows.Add(Mutations.CreateEntry(enumerator.Current.Key, Mutations.DeleteFromRow()));
}
}
if (deleteRows.Any())
{
bigtableClient.MutateRows(TableName.Parse(tableName), deleteRows);
}
}
public async Task NonRetryableErrorCodePreventsRetry()
{
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.FailedPrecondition),
Utilities.CreateMutateRowsResponseEntry(2, Code.DeadlineExceeded)
},
entriesForRetryStreams: null // No retries should be made
);
var entries = (await client.MutateRowsAsync(request)).Entries.OrderBy(e => e.Index).ToList();
Assert.Equal(3, entries.Count);
var entry = entries[0];
Assert.Equal(0, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[1];
Assert.Equal(1, entry.Index);
Assert.Equal((int)Code.FailedPrecondition, entry.Status.Code);
entry = entries[2];
Assert.Equal(2, entry.Index);
Assert.Equal((int)Code.DeadlineExceeded, entry.Status.Code);
}
protected override async Task DeleteMessagesToAsync(string persistenceId, long toSequenceNr)
{
var rows = RowSet.FromRowRanges(RowRange.Closed(ToRowKeyBigtableByteString(persistenceId, 0), ToRowKeyBigtableByteString(persistenceId, toSequenceNr)));
var stream = _bigtableClient.ReadRows(_tableName, rows: rows);
var deleteEntries = new List <MutateRowsRequest.Types.Entry>();
using (var enumerator = stream.GetEnumerator())
{
while (await enumerator.MoveNext().ConfigureAwait(false))
{
deleteEntries.Add(Mutations.CreateEntry(enumerator.Current.Key, Mutations.DeleteFromRow()));
}
}
if (deleteEntries.Any())
{
var last = deleteEntries.LastOrDefault();
deleteEntries.RemoveAt(deleteEntries.Count - 1);
deleteEntries.Add(Mutations.CreateEntry(last.RowKey, Mutations.SetCell(_family, PayloadColumnQualifier, ByteString.Empty, new BigtableVersion(-1))));
await _bigtableClient.MutateRowsAsync(_tableName, deleteEntries);
}
}
public void CreateEntryInvalidRowKey(BigtableByteString rowKey)
{
Assert.Throws <ArgumentException>(() => Mutations.CreateEntry(rowKey, Mutations.DeleteFromRow()));
}
protected override async Task DeleteAsync(string persistenceId, SnapshotSelectionCriteria criteria)
{
var filter = RowFilters.Chain
(
RowFilters.ColumnQualifierExact(SnapshotMetaDataColumnQualifier),
// this filter ensures that we only download snapshot metadata
RowFilters.TimestampRange(
ToUtc(criteria.MinTimestamp),
ToUtc(criteria.MaxTimeStamp)?.AddMilliseconds(1)
// add a milliseconds since the upper bound is exclusive
),
RowFilters.CellsPerColumnLimit(1)
);
var readRowsRequest = new ReadRowsRequest
{
TableNameAsTableName = _tableName,
Filter = filter,
Rows = GetRowSet(persistenceId, criteria.MinSequenceNr, criteria.MaxSequenceNr)
};
var deleteMutations = await _bigtableClient
.ReadRows(readRowsRequest)
.Select(SnapshotMetadataFromBigtableRow)
.Where(metadata => SatisfiesTimestampCriteria(criteria, metadata))
.Select(metadata => Mutations.CreateEntry(GetRowKey(persistenceId, metadata.SequenceNr), Mutations.DeleteFromRow()))
.ToList()
.ConfigureAwait(false);
if (deleteMutations.Count > 0)
{
await _bigtableClient.MutateRowsAsync(_tableName, deleteMutations).ConfigureAwait(false);
}
}
public void DeleteFromRow()
{
var mutation = Mutations.DeleteFromRow();
Assert.NotNull(mutation.DeleteFromRow);
}
public async Task MultipleRetries()
{
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow()),
Mutations.CreateEntry("d", Mutations.DeleteFromRow()),
Mutations.CreateEntry("e", Mutations.DeleteFromRow())
}
};
var client = MutateRowsStreamUtilities.CreateClientForMutateRowsRetries(
entriesForInitialResponse: new[]
{
MutateRowsStreamUtilities.CreateEntry(0, Code.Ok),
MutateRowsStreamUtilities.CreateEntry(1, Code.DeadlineExceeded),
MutateRowsStreamUtilities.CreateEntry(2, Code.Ok),
MutateRowsStreamUtilities.CreateEntry(3, Code.DeadlineExceeded),
MutateRowsStreamUtilities.CreateEntry(4, Code.DeadlineExceeded)
},
entriesForRetryResponses: new[]
{
// 1st retry response entries
new[]
{
// Original entry 1
MutateRowsStreamUtilities.CreateEntry(0, Code.Ok),
// Original entry 3
MutateRowsStreamUtilities.CreateEntry(1, Code.DeadlineExceeded),
// Original entry 4
MutateRowsStreamUtilities.CreateEntry(2, Code.Ok)
},
// 2nd retry response entries
new[]
{
// Original entry 3
MutateRowsStreamUtilities.CreateEntry(0, Code.FailedPrecondition)
}
});
var entries = (await client.MutateRowsAsync(request)).Entries.OrderBy(e => e.Index).ToList();
Assert.Equal(5, entries.Count);
var entry = entries[0];
Assert.Equal(0, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[1];
Assert.Equal(1, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[2];
Assert.Equal(2, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
entry = entries[3];
Assert.Equal(3, entry.Index);
Assert.Equal((int)Code.FailedPrecondition, entry.Status.Code);
entry = entries[4];
Assert.Equal(4, entry.Index);
Assert.Equal((int)Code.Ok, entry.Status.Code);
}
