/// <summary>Snippet for Rollback</summary>
public void Rollback_RequestObject()
{
// Snippet: Rollback(RollbackRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.Empty,
};
// Make the request
spannerClient.Rollback(request);
// End snippet
}
/// <summary>Snippet for Rollback</summary>
public void Rollback_RequestObject()
{
// Snippet: Rollback(RollbackRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Transaction = ByteString.Empty,
};
// Make the request
firestoreClient.Rollback(request);
// End snippet
}
/// <summary>Snippet for Rollback</summary>
public void RollbackRequestObject()
{
// Snippet: Rollback(RollbackRequest, CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Database = "",
Transaction = ByteString.Empty,
};
// Make the request
firestoreClient.Rollback(request);
// End snippet
}
public void Rollback()
{
moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Database = "projects/test/databases/databased8eee011",
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.Rollback(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
client.Rollback(request.Database, request.Transaction);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Roll back a transaction.
/// </summary>
/// <param name="project_id">Project ID against which to make the request.</param>
/// <param name="transaction">
/// The transaction identifier, returned by a call to
/// [google.datastore.v1beta3.Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
/// </param>
/// <param name="cancellationToken">If not null, a <see cref="CancellationToken"/> to use for this RPC.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <RollbackResponse> RollbackAsync(
string projectId,
ByteString transaction,
CancellationToken?cancellationToken = null,
CallSettings callSettings = null)
{
RollbackRequest request = new RollbackRequest
{
ProjectId = projectId,
Transaction = transaction,
};
return(GrpcClient.RollbackAsync(
request,
_clientHelper.BuildCallOptions(cancellationToken, callSettings)
).ResponseAsync);
}
public async Task RollbackAsync()
{
var client = new TransactionTestingClient();
var db = FirestoreDb.Create("proj", "db", client);
var transaction = await Transaction.BeginAsync(db, null, default);
await transaction.RollbackAsync();
var expectedRequest = new RollbackRequest
{
Database = "projects/proj/databases/db",
Transaction = ByteString.CopyFromUtf8("transaction 1")
};
Assert.Empty(client.CommitRequests);
Assert.Equal(new[] { expectedRequest }, client.RollbackRequests);
}
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
TransactionId = ByteString.CopyFromUtf8(""),
};
// Make the request
await spannerClient.RollbackAsync(request);
// End snippet
}
public async Task RollbackAsync2()
{
Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.CopyFromUtf8("28"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.RollbackAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null);
await client.RollbackAsync(request);
mockGrpcClient.VerifyAll();
}
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Create client
DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
ProjectId = "",
Transaction = ByteString.CopyFromUtf8(""),
};
// Make the request
RollbackResponse response = await datastoreClient.RollbackAsync(request);
// End snippet
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Transaction = ByteString.CopyFromUtf8(""),
};
// Make the request
await firestoreClient.RollbackAsync(request);
// End snippet
}
public async Task RollbackAsync2()
{
Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Transaction = ByteString.CopyFromUtf8("-34"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.RollbackAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
await client.RollbackAsync(request);
mockGrpcClient.VerifyAll();
}
public void Rollback2()
{
Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Transaction = ByteString.CopyFromUtf8("-34"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.Rollback(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
client.Rollback(request);
mockGrpcClient.VerifyAll();
}
public void Rollback2()
{
Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.CopyFromUtf8("28"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.Rollback(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null);
client.Rollback(request);
mockGrpcClient.VerifyAll();
}
public void Rollback()
{
moq::Mock <Datastore.DatastoreClient> mockGrpcClient = new moq::Mock <Datastore.DatastoreClient>(moq::MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
ProjectId = "project_id43ad98b0",
};
RollbackResponse expectedResponse = new RollbackResponse {
};
mockGrpcClient.Setup(x => x.Rollback(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
RollbackResponse response = client.Rollback(request.ProjectId, request.Transaction);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task RollbackAsync2()
{
Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
ProjectId = "projectId-1969970175",
Transaction = ByteString.CopyFromUtf8("-34"),
};
RollbackResponse expectedResponse = new RollbackResponse();
mockGrpcClient.Setup(x => x.RollbackAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <RollbackResponse>(Task.FromResult(expectedResponse), null, null, null, null));
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
RollbackResponse response = await client.RollbackAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void Rollback2()
{
Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
ProjectId = "projectId-1969970175",
Transaction = ByteString.CopyFromUtf8("-34"),
};
RollbackResponse expectedResponse = new RollbackResponse();
mockGrpcClient.Setup(x => x.Rollback(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
RollbackResponse response = client.Rollback(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackRequestObjectAsync()
{
// Snippet: RollbackAsync(RollbackRequest, CallSettings)
// Additional: RollbackAsync(RollbackRequest, CancellationToken)
// Create client
DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Transaction = ByteString.Empty,
ProjectId = "",
};
// Make the request
RollbackResponse response = await datastoreClient.RollbackAsync(request);
// End snippet
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Additional: RollbackAsync(RollbackRequest,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.Empty,
};
// Make the request
await spannerClient.RollbackAsync(request);
// End snippet
}
public async stt::Task RollbackAsync()
{
moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Database = "projects/test/databases/databased8eee011",
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.RollbackAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
await client.RollbackAsync(request.Database, request.Transaction, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
await client.RollbackAsync(request.Database, request.Transaction, st::CancellationToken.None);
mockGrpcClient.VerifyAll();
}
public async stt::Task RollbackAsync()
{
moq::Mock <Datastore.DatastoreClient> mockGrpcClient = new moq::Mock <Datastore.DatastoreClient>(moq::MockBehavior.Strict);
RollbackRequest request = new RollbackRequest
{
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
ProjectId = "project_id43ad98b0",
};
RollbackResponse expectedResponse = new RollbackResponse {
};
mockGrpcClient.Setup(x => x.RollbackAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <RollbackResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
RollbackResponse responseCallSettings = await client.RollbackAsync(request.ProjectId, request.Transaction, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
RollbackResponse responseCancellationToken = await client.RollbackAsync(request.ProjectId, request.Transaction, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
partial void Modify_RollbackRequest(ref RollbackRequest request, ref CallSettings settings) => ApplyResourcePrefixHeader(ref settings, request.Database);
public override Task RollbackAsync(RollbackRequest request, CallSettings callSettings = null) => Task.Run(() => Rollback(request, callSettings));
partial void Modify_RollbackRequest(ref RollbackRequest request, ref CallSettings settings)
{
settings = settings.WithHeader(ResourcePrefixHeader, "projects/" + request.ProjectId);
}
/// <summary>
/// Rolls back a transaction.
/// Documentation https://developers.google.com/datastore/v1beta3/reference/projects/rollback
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated datastore service.</param>
/// <param name="projectId">The ID of the project against which to make the request.</param>
/// <param name="body">A valid datastore v1beta3 body.</param>
/// <returns>RollbackResponseResponse</returns>
public static RollbackResponse Rollback(datastoreService service, string projectId, RollbackRequest body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
if (projectId == null)
{
throw new ArgumentNullException(projectId);
}
// Make the request.
return(service.Projects.Rollback(body, projectId).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Projects.Rollback failed.", ex);
}
}
/// <summary>
/// This request is used to issue a rollback on the Connection in the Phoenix query server identified by the given ID.
/// </summary>
public async Task<RollbackResponse> RollbackRequestAsync(string connectionId, RequestOptions options)
{
RollbackRequest req = new RollbackRequest
{
ConnectionId = connectionId
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "RollbackRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"RollbackRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
RollbackResponse res = RollbackResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}