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); }