private void RemoveUserActivationCode(string userName)
{
try
{
DBSession.StartTransaction();
UserCollection.DeleteOne(user => user.UserName.Equals(user.UserName));
DBSession.CommitTransaction();
}
catch (System.Exception)
{
DBSession.AbortTransaction();
throw;
}
}
internal void CommitTransaction()
{
if (IsInRunningState())
{
_transactionSession.CommitTransaction();
}
}
public override void Commit()
{
base.Commit();
_clientSessionHandle.CommitTransaction();
_clientSessionHandle.Dispose();
_clientSessionHandle = null;
}
public static void CommitWithRetry(this IClientSessionHandle session)
{
while (true)
{
try
{
session.CommitTransaction();
Console.WriteLine("Transaction committed.");
break;
}
catch (MongoException exception)
{
// can retry commit
// Driver already attempts a retry ONCE if there's a network class error.
// In face of "write concern timeout" exception, driver retries once, but you may see "UnknownTransactionCommitResult" if that failed.
if (exception.HasErrorLabel("UnknownTransactionCommitResult"))
{
Console.WriteLine("UnknownTransactionCommitResult, retrying commit operation");
continue;
}
else
{
Console.WriteLine($"Error during commit: {exception.Message}.");
throw;
}
}
}
}
public void Commit()
{
if (_transactionCounter == 1)
{
try
{
Transaction.Commit();
_mongoSession.CommitTransaction();
}
catch
{
Transaction.Rollback();
_mongoSession.AbortTransaction();
throw;
}
finally
{
_connection.Close();
Transaction.Dispose();
_mongoSession.Dispose();
}
}
_transactionCounter--;
}
private static bool CommitWithRetries(IClientSessionHandle clientSession, DateTime startTime, IClock clock, CancellationToken cancellationToken)
{
while (true)
{
try
{
clientSession.CommitTransaction(cancellationToken);
return(true);
}
catch (Exception ex)
{
var now = clock.UtcNow; // call UtcNow once since we need to facilitate predictable mocking
if (ShouldRetryCommit(ex, startTime, now))
{
continue;
}
if (HasErrorLabel(ex, TransientTransactionErrorLabel) && !HasTimedOut(startTime, now))
{
return(false); // the transaction will be retried
}
throw;
}
}
}
public void Commit()
{
if (_clientSession.IsInTransaction)
{
_clientSession.CommitTransaction();
}
}
// Start Transactions Retry Example 2
public void CommitWithRetry(IClientSessionHandle session)
{
while (true)
{
try
{
session.CommitTransaction(); // uses write concern set at transaction start
Console.WriteLine("Transaction committed.");
break;
}
catch (MongoException exception)
{
// can retry commit
if (exception.HasErrorLabel("UnknownTransactionCommitResult"))
{
Console.WriteLine("UnknownTransactionCommitResult, retrying commit operation.");
continue;
}
else
{
Console.WriteLine($"Excpetion during commit: {exception.Message}.");
throw;
}
}
}
}
public void Commit()
{
if (_session != null)
{
_session.CommitTransaction();
}
_session = null;
}
public void CommitTransaction()
{
if (_session == null)
{
throw new InvalidOperationException("Transaction already closed");
}
_session.CommitTransaction();
}
/// <summary>
/// Commits data transaction to data source if applicable
/// </summary>
public void Commit()
{
if (!AutoCommit)
{
_transSession.CommitTransaction();
_transSession = _client.StartSession();
}
}
public void CommitTransaction()
{
if (session == null)
{
throw new CjExpInvalidOperationException("Transaction session not started");
}
session.CommitTransaction();
session = null;
}
// Start Transaction Intro Example 1
public void UpdateEmployeeInfo(IMongoClient client, IClientSessionHandle session)
{
var employeesCollection = client.GetDatabase("hr").GetCollection <BsonDocument>("employees");
var eventsCollection = client.GetDatabase("reporting").GetCollection <BsonDocument>("events");
session.StartTransaction(new TransactionOptions(
readConcern: ReadConcern.Snapshot,
writeConcern: WriteConcern.WMajority));
try
{
employeesCollection.UpdateOne(
session,
Builders <BsonDocument> .Filter.Eq("employee", 3),
Builders <BsonDocument> .Update.Set("status", "Inactive"));
eventsCollection.InsertOne(
session,
new BsonDocument
{
{ "employee", 3 },
{ "status", new BsonDocument {
{ "new", "Inactive" }, { "old", "Active" }
} }
});
}
catch (Exception exception)
{
Console.WriteLine($"Caught exception during transaction, aborting: {exception.Message}.");
session.AbortTransaction();
throw;
}
while (true)
{
try
{
session.CommitTransaction(); // uses write concern set at transaction start
Console.WriteLine("Transaction committed.");
break;
}
catch (MongoException exception)
{
// can retry commit
if (exception.HasErrorLabel("UnknownTransactionCommitResult"))
{
Console.WriteLine("UnknownTransactionCommitResult, retrying commit operation.");
continue;
}
else
{
Console.WriteLine("Error during commit.");
throw;
}
}
}
}
public Result BookingSeat(int totalSeats, string seatIds, string jsonBooked, IMessage msg)
{
Result result;
using (IDataAdapter da = DataManager.Build(this.DbConfig))
{
IClientSessionHandle Session = null;
try
{
string tickets = "";
string seatUnavailable = @"
{
_id: {'$in': <ids>},
'bookingStatus._id': {'$ne': 'bs01'}
}
".Replace("<ids>", seatIds);
Session = da.Open()
.CreateTransaction();
Session.StartTransaction();
da.Get(seatUnavailable, out tickets);
if (tickets != "[]")
{
Session.AbortTransaction();
throw new System.InvalidOperationException("Unavailable ticket:" + tickets);
}
string bookSeats = @"
{
'_id': {'$in': <ids>}
}
".Replace("<ids>", seatIds);
long total = 0;
da.EditMany(bookSeats, jsonBooked, out total);
if (totalSeats != total)
{
Session.AbortTransaction();
throw new System.InvalidOperationException("Unavailable book all ticktes!");
}
Session.CommitTransaction();
result = Result.GetResult(BusinessStatus.Completed, 210, msg, "Booking is successfully.");
}
catch (Exception err)
{
if (Session != null)
{
Session.AbortTransaction();
}
result = Result.GetResult(BusinessStatus.Completed, 500, msg, err.Message);
}
}
return(result);
}
public void Commit()
{
if (_session == null)
{
throw new Exception("Session has been gone somehow!");
}
_session.CommitTransaction();
_session.Dispose();
}
public void Commit()
{
try
{
_transactionSession.CommitTransaction();
}
finally
{
_transactionSession.Dispose();
}
}
public OperationResult Execute(CancellationToken cancellationToken)
{
try
{
_session.CommitTransaction(cancellationToken);
return(OperationResult.Empty());
}
catch (Exception ex)
{
return(OperationResult.FromException(ex));
}
}
public void Commit(Enlistment enlistment)
{
try
{
_sessionHandle.CommitTransaction();
enlistment.Done();
}
finally
{
_unregister();
}
}
public int SalvarAlteracoes()
{
try
{
_session.CommitTransaction();
return(1);
}
catch
{
_session.AbortTransaction();
return(0);
}
}
/// <summary>
/// Commit Transaction
/// </summary>
public void CommitTransaction()
{
if (conn == null)
{
throw new Exception("Connection has not initialize.");
}
if (session == null)
{
throw new Exception("StartTransaction has not initialize.");
}
session.CommitTransaction();
}
public void CommitTransaction(CancellationToken cancellationToken = default(CancellationToken))
{
if (DotUseTransaction)
{
return;
}
Policy.Handle <MongoConnectionException>(i => i.InnerException.GetType() == typeof(IOException) || i.InnerException.GetType() == typeof(SocketException))
.Or <MongoException>(i => i.HasErrorLabel("UnknownTransactionCommitResult") || i.HasErrorLabel("TransientTransactionError")) //TransientTransactionError
.Retry(3, (exception, retryCount) => { Console.WriteLine("Retry." + retryCount); })
.Execute(() =>
{
session.CommitTransaction(cancellationToken);
});
}
public void CommitTransaction_NoError()
{
//Act
Action action = () =>
{
using (IClientSessionHandle session = _mongoRsResource.Client.StartSession())
{
IMongoCollection <BsonDocument> collection = _mongoRsResource.CreateCollection <BsonDocument>("bar");
session.StartTransaction();
collection.InsertOne(session, new BsonDocument("name", "test"));
session.CommitTransaction();
}
};
//Assert
action.Should().NotThrow();
}
/// <summary>
/// Insert entity
/// </summary>
/// <param name="entity">Entity</param>
public virtual T Insert(T entity)
{
StartTransaction();
try
{
_collection.InsertOne(entity);
_session.CommitTransaction();
return(entity);
}
catch (Exception)
{
_session.AbortTransaction();
throw;
}
}
protected override void MarkJobFailedImpl(Guid jobId, Exception cause)
{
//TODO Docs
using (IClientSessionHandle session = _client.StartSession())
{
session.StartTransaction();
try
{
if (!TryGetMongoExtractJobDoc(jobId, out MongoExtractJobDoc toFail))
{
throw new ApplicationException($"Could not find job {jobId} in the job store");
}
if (toFail.JobStatus == ExtractJobStatus.Failed || toFail.FailedJobInfoDoc != null)
{
throw new ApplicationException($"Job {jobId} is already marked as failed");
}
toFail.JobStatus = ExtractJobStatus.Failed;
toFail.FailedJobInfoDoc = new MongoFailedJobInfoDoc(cause, _dateTimeProvider);
ReplaceOneResult res = _inProgressJobCollection.ReplaceOne(GetFilterForSpecificJob <MongoExtractJobDoc>(jobId), toFail);
if (!res.IsAcknowledged || res.ModifiedCount != 1)
{
throw new ApplicationException($"Received invalid ReplaceOneResult: {res}");
}
}
catch (Exception)
{
Logger.Debug("Caught exception from transaction. Aborting before re-throwing");
session.AbortTransaction();
throw;
}
// TODO(rkm 2020-03-03) Can potentially add a retry here
session.CommitTransaction();
}
}
protected override void CommitTransaction()
{
_session.CommitTransaction();
}
public void CommitTransaction()
{
mongoSession.CommitTransaction();
}
public void Commit(Enlistment enlistment)
{
Retryer.Retry(() => _session.CommitTransaction(), _maxRetries);
enlistment.Done();
}
//public List<User> GetUsers()
//{
// //Create the collection object that represents the "users" collection
// var users = session.Client.GetDatabase("MyPerformance").GetCollection<User>("users");
// return users;
//}
public async Task <List <User> > InitUsers(List <User> existingUsers)
{
var users = session.Client.GetDatabase("MyPerformance").GetCollection <User>("users");
//Clean up the collection if there is data in there
// users.Database.DropCollection("users");
PrincipalContext ctx = new PrincipalContext(ContextType.Machine, Environment.MachineName);
UserPrincipal user = new UserPrincipal(ctx);
user.Name = "*";
PrincipalSearcher ps = new PrincipalSearcher();
ps.QueryFilter = user;
PrincipalSearchResult <Principal> result = ps.FindAll();
var machineId = Machine.GetMachineId();
try
{
Console.WriteLine("User Accounts\n");
foreach (Principal p in result)
{
using (UserPrincipal mo = (UserPrincipal)p)
{
Console.WriteLine("Account : " + mo.Name);
//Begin transaction
Console.WriteLine("Local, checking if already exists");
// check if the user already exists
if (existingUsers.Any(_ => _.Name == mo.Name.ToString()))
{
continue;
}
Console.WriteLine("Adding : " + mo.Name);
session.StartTransaction();
try
{
var newUser = new User
{
Name = mo.Name,
MachineId = machineId,
SamAccountName = mo.SamAccountName,
DisplayName = mo.DisplayName,
SID = mo.Sid.ToString(),
UserPrincipalName = mo.UserPrincipalName,
Description = mo.Description
};
await users.InsertOneAsync(newUser);
session.CommitTransaction();
existingUsers.Add(newUser);
}
catch (Exception e)
{
session.AbortTransaction();
Console.WriteLine("Error writing to MongoDB: " + e.Message);
}
}
}
return(existingUsers);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(existingUsers);
}
}
public IDataAdapter CommitTransaction()
{
_session.CommitTransaction();
return(this);
}
public void Execute()
{
_session.CommitTransaction();
}