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