/// <summary>Snippet for BeginTransaction</summary> public void BeginTransactionRequestObject() { // Snippet: BeginTransaction(BeginTransactionRequest, CallSettings) // Create client FirestoreClient firestoreClient = FirestoreClient.Create(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { Database = "", Options = new TransactionOptions(), }; // Make the request BeginTransactionResponse response = firestoreClient.BeginTransaction(request); // End snippet }
internal static async Task <Transaction> BeginAsync(FirestoreDb db, ByteString previousTransactionId, CancellationToken cancellationToken) { var request = new BeginTransactionRequest { Database = db.RootPath, Options = previousTransactionId == null ? null : new V1Beta1.TransactionOptions { ReadWrite = new ReadWrite { RetryTransaction = previousTransactionId } } }; var response = await db.Client.BeginTransactionAsync(request, CallSettings.FromCancellationToken(cancellationToken)).ConfigureAwait(false); return(new Transaction(db, response.Transaction, cancellationToken)); }
/// <summary>Snippet for BeginTransaction</summary> public void BeginTransaction_RequestObject() { // Snippet: BeginTransaction(BeginTransactionRequest,CallSettings) // Create client SpannerClient spannerClient = SpannerClient.Create(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"), Options = new TransactionOptions(), }; // Make the request Transaction response = spannerClient.BeginTransaction(request); // End snippet }
public async Task ReleaseToPool_SessionInvalidatedByServer() { var pool = new FakeSessionPool(); var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName); // Make a request which fails due to the session not being found (because it has expired). var request = new BeginTransactionRequest(); pool.Mock.Setup(client => client.BeginTransactionAsync(request, It.IsAny <CallSettings>())) .ThrowsAsync(new RpcException(new Status(StatusCode.NotFound, "Session not found"))); await Assert.ThrowsAsync <RpcException>(() => pooledSession.BeginTransactionAsync(request, 5, CancellationToken.None)); // When we release the session, the pool should delete it even if we didn't ask it to. pooledSession.ReleaseToPool(false); Assert.True(pool.ReleasedSessionDeleted); }
/// <summary>Snippet for BeginTransactionAsync</summary> public async Task BeginTransactionAsync_RequestObject() { // Snippet: BeginTransactionAsync(BeginTransactionRequest,CallSettings) // Create client FirestoreClient firestoreClient = await FirestoreClient.CreateAsync(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(), }; // Make the request BeginTransactionResponse response = await firestoreClient.BeginTransactionAsync(request); // End snippet }
public override BeginTransactionResponse BeginTransaction(BeginTransactionRequest request, CallSettings callSettings = null) { int id = Interlocked.Increment(ref _transactions); string text = $"transaction {id}"; ByteString retry = request.Options?.ReadWrite?.RetryTransaction; if (retry != null) { // We don't want to chain "transaction 5; retrying transaction 4; retrying transaction 3" etc. string retryText = retry.ToStringUtf8().Split(';')[0]; text += $"; retrying {retryText}"; } return(new BeginTransactionResponse { Transaction = ByteString.CopyFromUtf8(text) }); }
public async Task BeginTransactionAsync_RequestObject() { // Snippet: BeginTransactionAsync(BeginTransactionRequest,CallSettings) // Create client DatastoreClient datastoreClient = await DatastoreClient.CreateAsync(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { ProjectId = "", }; // Make the request BeginTransactionResponse response = await datastoreClient.BeginTransactionAsync(request); // End snippet }
public async Task BeginTransactionAsync_RequestObject() { // Snippet: BeginTransactionAsync(BeginTransactionRequest,CallSettings) // Create client SpannerClient spannerClient = await SpannerClient.CreateAsync(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(), Options = new TransactionOptions(), }; // Make the request Transaction response = await spannerClient.BeginTransactionAsync(request); // End snippet }
public async Task DetectSessionExpiry() { var pool = new FakeSessionPool(); var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName); // Make a request which fails due to the session not being found (because it has expired). var request = new BeginTransactionRequest(); pool.Mock.Setup(client => client.BeginTransactionAsync(request, It.IsAny <CallSettings>())) .ThrowsAsync(new RpcException(new Status(StatusCode.NotFound, "Session not found"))) .Verifiable(); await Assert.ThrowsAsync <RpcException>(() => pooledSession.BeginTransactionAsync(request, 5, CancellationToken.None)); Assert.True(pooledSession.ServerExpired); pool.Mock.Verify(); }
/// <summary>Snippet for BeginTransactionAsync</summary> public async Task BeginTransactionRequestObjectAsync() { // Snippet: BeginTransactionAsync(BeginTransactionRequest, CallSettings) // Additional: BeginTransactionAsync(BeginTransactionRequest, CancellationToken) // Create client FirestoreClient firestoreClient = await FirestoreClient.CreateAsync(); // Initialize request argument(s) BeginTransactionRequest request = new BeginTransactionRequest { Database = "", Options = new TransactionOptions(), }; // Make the request BeginTransactionResponse response = await firestoreClient.BeginTransactionAsync(request); // End snippet }
public async Task RequestSessionIsPopulated() { var pool = new FakeSessionPool(); var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName); // Make a successful request var request = new BeginTransactionRequest(); pool.Mock.Setup(client => client.BeginTransactionAsync(request, It.IsAny <CallSettings>())) .ReturnsAsync(new Transaction()) .Verifiable(); await pooledSession.BeginTransactionAsync(request, 5, CancellationToken.None); // The call modifies the request. (We can't easily check that it was modified before the RPC) Assert.Equal(s_sampleSessionName, request.SessionAsSessionName); pool.Mock.Verify(); }
public void BeginTransaction() { moq::Mock <Datastore.DatastoreClient> mockGrpcClient = new moq::Mock <Datastore.DatastoreClient>(moq::MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { ProjectId = "project_id43ad98b0", }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"), }; mockGrpcClient.Setup(x => x.BeginTransaction(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse response = client.BeginTransaction(request.ProjectId); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async Task BeginTransactionAsync2() { Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(), }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = ByteString.CopyFromUtf8("-34"), }; mockGrpcClient.Setup(x => x.BeginTransactionAsync(request, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <BeginTransactionResponse>(Task.FromResult(expectedResponse), null, null, null, null)); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse response = await client.BeginTransactionAsync(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void BeginTransactionRequestObject() { moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { Database = "projects/test/databases/databased8eee011", Options = new TransactionOptions(), }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"), }; mockGrpcClient.Setup(x => x.BeginTransaction(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse response = client.BeginTransaction(request); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async Task BeginTransactionAsync2() { Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { ProjectId = "projectId-1969970175", }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = ByteString.CopyFromUtf8("-34"), }; mockGrpcClient.Setup(x => x.BeginTransactionAsync(request, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <BeginTransactionResponse>(Task.FromResult(expectedResponse), null, null, null, null)); DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse response = await client.BeginTransactionAsync(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void BeginTransaction2() { Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { ProjectId = "projectId-1969970175", }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = ByteString.CopyFromUtf8("-34"), }; mockGrpcClient.Setup(x => x.BeginTransaction(request, It.IsAny <CallOptions>())) .Returns(expectedResponse); DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse response = client.BeginTransaction(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void BeginTransaction() { Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict); BeginTransactionRequest expectedRequest = new BeginTransactionRequest { Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(), }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = ByteString.CopyFromUtf8("-34"), }; mockGrpcClient.Setup(x => x.BeginTransaction(expectedRequest, It.IsAny <CallOptions>())) .Returns(expectedResponse); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); string formattedDatabase = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(); BeginTransactionResponse response = client.BeginTransaction(formattedDatabase); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async Task BeginTransactionAsync2() { Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"), Options = new TransactionOptions(), }; Transaction expectedResponse = new Transaction { Id = ByteString.CopyFromUtf8("27"), }; mockGrpcClient.Setup(x => x.BeginTransactionAsync(request, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <Transaction>(Task.FromResult(expectedResponse), null, null, null, null)); SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null); Transaction response = await client.BeginTransactionAsync(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async stt::Task BeginTransactionAsync() { moq::Mock <Datastore.DatastoreClient> mockGrpcClient = new moq::Mock <Datastore.DatastoreClient>(moq::MockBehavior.Strict); BeginTransactionRequest request = new BeginTransactionRequest { ProjectId = "project_id43ad98b0", }; BeginTransactionResponse expectedResponse = new BeginTransactionResponse { Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"), }; mockGrpcClient.Setup(x => x.BeginTransactionAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <BeginTransactionResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null)); DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null); BeginTransactionResponse responseCallSettings = await client.BeginTransactionAsync(request.ProjectId, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); BeginTransactionResponse responseCancellationToken = await client.BeginTransactionAsync(request.ProjectId, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public async Task AutoRefreshOnSuccessfulRpc() { var pool = new FakeSessionPool(); var options = pool.Options; var clock = (FakeClock)options.Clock; var originalTime = clock.GetCurrentDateTimeUtc(); var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName); var halfRefresh = TimeSpan.FromTicks(options.IdleSessionRefreshDelay.Ticks / 2); clock.Advance(halfRefresh); // Make a successful request var request = new BeginTransactionRequest(); var response = new Transaction(); pool.Mock.Setup(client => client.BeginTransactionAsync(request, It.IsAny <CallSettings>())).ReturnsAsync(response); await pooledSession.BeginTransactionAsync(request, 5, CancellationToken.None); // The request will have extended the refresh time. Assert.Equal(clock.GetCurrentDateTimeUtc() + options.IdleSessionRefreshDelay, pooledSession.RefreshTimeForTest); }
public void BeginTransaction() { Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict); BeginTransactionRequest expectedRequest = new BeginTransactionRequest { SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"), Options = new TransactionOptions(), }; Transaction expectedResponse = new Transaction { Id = ByteString.CopyFromUtf8("27"), }; mockGrpcClient.Setup(x => x.BeginTransaction(expectedRequest, It.IsAny <CallOptions>())) .Returns(expectedResponse); SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null); SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"); TransactionOptions options = new TransactionOptions(); Transaction response = client.BeginTransaction(session, options); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
/// <summary> /// Begins a new transaction. /// Documentation https://developers.google.com/datastore/v1beta3/reference/projects/beginTransaction /// 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>BeginTransactionResponseResponse</returns> public static BeginTransactionResponse BeginTransaction(datastoreService service, string projectId, BeginTransactionRequest 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.BeginTransaction(body, projectId).Execute()); } catch (Exception ex) { throw new Exception("Request Projects.BeginTransaction failed.", ex); } }
public void manyFacedGod(Dictionary <string, string> assets) { var projectId = assets[Constants.ASSET_PROJECT_ID]; var credential = GetDefaultCredential(assets, _assetManager); // Create the service. var datastore = GetDatastoreService(credential, assets); //create the keys //assign ids var keys = allocateIds(datastore, new List <Key> { getKey("jhpsystems"), getKey("jhpsystems"), getKey("jhpsystems") }, projectId ); //select __key__, cardserial, registerno From jhpsystems //assign to entities var entities = new List <Mutation>(); var x = 1; foreach (var key in keys) { x++; var entity = new Entity() { Key = key }; entity.Properties = new Dictionary <string, Value>() { { "cardserial", new Value() { IntegerValue = 20 * x } }, { "datablob", new Value() { StringValue = "This is a blob " + x } }, { "registerno", new Value() { IntegerValue = 330 + x } }, { "dateadded", new Value() { TimestampValue = DateTime.Now } } }; entities.Add(new Mutation() { Upsert = entity }); } //we figure out how to save var tr = new BeginTransactionRequest() { }; var trid = datastore.Projects.BeginTransaction(tr, projectId); var mut = new Mutation() { Upsert = new Entity() }; var cr = new CommitRequest() { Mutations = entities }; datastore.Projects.Commit(cr, projectId); //perhaps we save to the local database //alert that we are done saving var t = 0; }
partial void Modify_BeginTransactionRequest(ref BeginTransactionRequest request, ref CallSettings settings) => ApplyResourcePrefixHeader(ref settings, request.Database);
partial void Modify_BeginTransactionRequest(ref BeginTransactionRequest request, ref CallSettings settings) { settings = settings.WithHeader(ResourcePrefixHeader, "projects/" + request.ProjectId); }
// Async wrappers for the synchronous implementations. // Using Task.Run instead of Task.FromResult to allow exceptions to be propagated as faulted tasks. public override Task <BeginTransactionResponse> BeginTransactionAsync(BeginTransactionRequest request, CallSettings callSettings = null) => Task.Run(() => BeginTransaction(request, callSettings));