/// <summary>
/// Notifies an enlisted object that a transaction is being prepared for commitment.
/// </summary>
/// <param name="preparingEnlistment">A <see cref="T:System.Transactions.PreparingEnlistment"/> object used to send a response to the transaction manager.</param>
public void Prepare(PreparingEnlistment preparingEnlistment)
{
onTxComplete();
session.StoreRecoveryInformation(session.ResourceManagerId, PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction),
preparingEnlistment.RecoveryInformation());
preparingEnlistment.Prepared();
}
/// <summary>
/// Notifies an enlisted object that a transaction is being prepared for commitment.
/// </summary>
/// <param name="preparingEnlistment">A <see cref="T:System.Transactions.PreparingEnlistment"/> object used to send a response to the transaction manager.</param>
public void Prepare(PreparingEnlistment preparingEnlistment)
{
onTxComplete();
try
{
using (var machineStoreForApplication = IsolatedStorageFile.GetMachineStoreForDomain())
{
var name = TransactionRecoveryInformationFileName;
using (var file = machineStoreForApplication.CreateFile(name + ".temp"))
using (var writer = new BinaryWriter(file))
{
writer.Write(session.ResourceManagerId.ToString());
writer.Write(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction).ToString());
writer.Write(session.DatabaseName ?? "");
writer.Write(preparingEnlistment.RecoveryInformation());
file.Flush(true);
}
machineStoreForApplication.MoveFile(name + ".temp", name);
}
}
catch (Exception e)
{
logger.ErrorException("Could not prepare distributed transaction", e);
preparingEnlistment.ForceRollback(e);
return;
}
preparingEnlistment.Prepared();
}
public virtual void Prepare(PreparingEnlistment preparingEnlistment)
{
Trace.WriteIf(Tracing.Is.TraceVerbose, string.Empty);
if (null == preparingEnlistment)
{
return;
}
try
{
Operation.Info = Convert.ToBase64String(preparingEnlistment.RecoveryInformation());
if (ConfigureOperation() &&
Operation.Do())
{
Trace.WriteIf(Tracing.Is.TraceVerbose, "preparingEnlistment.Prepared()");
preparingEnlistment.Prepared();
return;
}
Trace.WriteIf(Tracing.Is.TraceVerbose, "preparingEnlistment.ForceRollback()");
preparingEnlistment.ForceRollback();
}
catch (Exception exception)
{
Trace.TraceError("{0}", exception);
preparingEnlistment.ForceRollback(exception);
}
}
/// <summary>
/// Notifies an enlisted object that a transaction is being prepared for commitment.
/// </summary>
/// <param name="preparingEnlistment">A <see cref="T:System.Transactions.PreparingEnlistment"/> object used to send a response to the transaction manager.</param>
public void Prepare(PreparingEnlistment preparingEnlistment)
{
try
{
onTxComplete();
ctx.CreateFile(TransactionRecoveryInformationFileName, stream =>
{
var writer = new BinaryWriter(stream);
writer.Write(session.ResourceManagerId.ToString());
writer.Write(transaction.LocalIdentifier);
writer.Write(session.DatabaseName ?? "");
writer.Write(preparingEnlistment.RecoveryInformation());
});
session.PrepareTransaction(transaction.LocalIdentifier);
}
catch (Exception e)
{
logger.ErrorException("Could not prepare distributed transaction", e);
try
{
session.Rollback(transaction.LocalIdentifier);
DeleteFile();
}
catch (Exception e2)
{
logger.ErrorException("Could not roll back transaction after prepare failed", e2);
}
preparingEnlistment.ForceRollback(e);
return;
}
preparingEnlistment.Prepared();
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
uint method = 0x4fe;
this.TrEntry(method, new object[] { preparingEnlistment });
Exception e = null;
bool flag = false;
try
{
if (base.asyncFailureNotify != null)
{
base.TrText(method, "Rollback the tx as we have an async failure");
preparingEnlistment.ForceRollback(base.asyncFailureNotify);
flag = true;
}
else
{
base.TrText(method, "Hconn =" + base.hconn.Value + " has been asked to Prepare by the Transaction Co-ordinator");
base.MQRMIXAEnd();
if (base.MQRMIXAPrepare(preparingEnlistment.RecoveryInformation()) == 3)
{
flag = true;
preparingEnlistment.Done();
}
else
{
base.TrText(method, "WMQ .NET is now prepared..");
preparingEnlistment.Prepared();
}
}
}
catch (MQException exception2)
{
base.TrException(method, exception2, 1);
e = exception2;
preparingEnlistment.ForceRollback(e);
flag = true;
}
catch (Exception exception3)
{
base.TrException(method, exception3, 2);
e = exception3;
preparingEnlistment.ForceRollback(e);
flag = true;
}
finally
{
if (flag)
{
this.rmiTxComplete = true;
if (base.hconn != null)
{
base.hconn.PulseCommitWait();
}
}
base.TrExit(method);
}
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
byte[] recoveryInformation = preparingEnlistment.RecoveryInformation();
var ravenJObject = new RavenJObject
{
{ Constants.NotForReplication, true }
};
database.PutStatic("transactions/recoveryInformation/" + txId, null, new MemoryStream(recoveryInformation), ravenJObject);
preparingEnlistment.Prepared();
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
_assertNotDisposed();
_logger.Debug("Preparing enlistment with id: {0}", Id);
var information = preparingEnlistment.RecoveryInformation();
_queueStorage.Global(actions =>
{
actions.RegisterRecoveryInformation(Id, information);
});
preparingEnlistment.Prepared();
_logger.Debug("Prepared enlistment with id: {0}", Id);
}
/// <summary>
/// Notifies an enlisted object that a transaction is being prepared for commitment.
/// </summary>
/// <param name="preparingEnlistment">A <see cref="T:System.Transactions.PreparingEnlistment"/> object used to send a response to the transaction manager.</param>
public void Prepare(PreparingEnlistment preparingEnlistment)
{
onTxComplete();
try
{
session.StoreRecoveryInformation(session.ResourceManagerId, PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction),
preparingEnlistment.RecoveryInformation());
}
catch (Exception e)
{
logger.ErrorException("Could not prepare distributed transaction", e);
preparingEnlistment.ForceRollback(e);
return;
}
preparingEnlistment.Prepared();
}
public async Task PrepareAsync(PreparingEnlistment preparingEnlistment)
{
using (await this.syncObject.LockAsync().Await())
{
this.netTxState = TxState.Pending;
try
{
Tracer.Debug("Prepare notification received for TX id: " + this.TransactionId);
await BeforeEndAsync().Await();
// Before sending the request to the broker, log the recovery bits, if
// this fails we can't prepare and the TX should be rolled back.
RecoveryLogger.LogRecoveryInfo(this.TransactionId as XATransactionId,
preparingEnlistment.RecoveryInformation());
// Inform the broker that work on the XA'sh TX Branch is complete.
TransactionInfo info = new TransactionInfo();
info.ConnectionId = this.connection.ConnectionId;
info.TransactionId = this.TransactionId;
info.Type = (int)TransactionType.End;
await this.connection.CheckConnectedAsync().Await();
await this.connection.SyncRequestAsync((TransactionInfo)info.Clone()).Await();
// Prepare the Transaction for commit.
info.Type = (int)TransactionType.Prepare;
IntegerResponse response = (IntegerResponse)await this.connection.SyncRequestAsync(info).Await();
if (response.Result == XA_READONLY)
{
Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.TransactionId);
this.TransactionId = null;
this.currentEnlistment = null;
// Read Only means there's nothing to recover because there was no
// change on the broker.
RecoveryLogger.LogRecovered(this.TransactionId as XATransactionId);
// if server responds that nothing needs to be done, then reply done.
// otherwise the DTC will call Commit or Rollback but another transaction
// can already be in progress and this one would be commited or rolled back
// immediately.
preparingEnlistment.Done();
// Done so commit won't be called.
AfterCommit();
// A Read-Only TX is considered closed at this point, DTC won't call us again.
this.dtcControlEvent.Set();
}
else
{
Tracer.Debug("Transaction Prepare succeeded TX id: " + this.TransactionId);
// If work finished correctly, reply prepared
preparingEnlistment.Prepared();
}
}
catch (Exception ex)
{
Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}",
this.TransactionId, ex.Message);
AfterRollback();
preparingEnlistment.ForceRollback();
try
{
this.connection.OnAsyncException(ex);
}
catch (Exception error)
{
Tracer.Error(error.ToString());
}
this.currentEnlistment = null;
this.TransactionId = null;
this.netTxState = TxState.None;
this.dtcControlEvent.Set();
}
}
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
database.PutStatic("transactions/recoveryInformation/" + txId, null, preparingEnlistment.RecoveryInformation(), new RavenJObject());
preparingEnlistment.Prepared();
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
session.StoreRecoveryInformation(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction), preparingEnlistment.RecoveryInformation());
preparingEnlistment.Prepared();
}
public byte[] GetRecoveryInformation(PreparingEnlistment preparingEnlistment)
{
return(preparingEnlistment.RecoveryInformation());
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
byte[] recoveryInformation = preparingEnlistment.RecoveryInformation();
database.PutStatic("transactions/recoveryInformation/" + txId, null, new MemoryStream(recoveryInformation), new RavenJObject());
preparingEnlistment.Prepared();
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
try
{
dtcControlEvent.Reset();
Tracer.Debug("Prepare notification received for TX id: " + this.transactionId);
BeforeEnd();
// Before sending the request to the broker, log the recovery bits, if
// this fails we can't prepare and the TX should be rolled back.
RecoveryLogger.LogRecoveryInfo(this.transactionId as XATransactionId,
preparingEnlistment.RecoveryInformation());
// Inform the broker that work on the XA'sh TX Branch is complete.
TransactionInfo info = new TransactionInfo();
info.ConnectionId = this.connection.ConnectionId;
info.TransactionId = this.transactionId;
info.Type = (int)TransactionType.End;
this.connection.CheckConnected();
this.connection.SyncRequest(info);
// Prepare the Transaction for commit.
info.Type = (int)TransactionType.Prepare;
IntegerResponse response = (IntegerResponse)this.connection.SyncRequest(info);
if (response.Result == XA_READONLY)
{
Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.transactionId);
this.transactionId = null;
this.currentEnlistment = null;
// Read Only means there's nothing to recover because there was no
// change on the broker.
RecoveryLogger.LogRecovered(this.transactionId as XATransactionId);
// if server responds that nothing needs to be done, then reply prepared
// but clear the current state data so we appear done to the commit method.
preparingEnlistment.Prepared();
// Done so commit won't be called.
AfterCommit();
}
else
{
Tracer.Debug("Transaction Prepare succeeded TX id: " + this.transactionId);
// If work finished correctly, reply prepared
preparingEnlistment.Prepared();
}
}
catch (Exception ex)
{
Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}",
this.transactionId, ex.Message);
AfterRollback();
preparingEnlistment.ForceRollback();
try
{
this.connection.OnException(ex);
}
catch (Exception error)
{
Tracer.Error(error.ToString());
}
this.currentEnlistment = null;
this.transactionId = null;
}
finally
{
this.dtcControlEvent.Set();
}
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
try
{
dtcControlEvent.Reset();
Tracer.Debug("Prepare notification received for TX id: " + this.transactionId);
BeforeEnd();
// Before sending the request to the broker, log the recovery bits, if
// this fails we can't prepare and the TX should be rolled back.
RecoveryLogger.LogRecoveryInfo(this.transactionId as XATransactionId,
preparingEnlistment.RecoveryInformation());
// Inform the broker that work on the XA'sh TX Branch is complete.
TransactionInfo info = new TransactionInfo();
info.ConnectionId = this.connection.ConnectionId;
info.TransactionId = this.transactionId;
info.Type = (int) TransactionType.End;
this.connection.CheckConnected();
this.connection.SyncRequest(info);
// Prepare the Transaction for commit.
info.Type = (int) TransactionType.Prepare;
IntegerResponse response = (IntegerResponse) this.connection.SyncRequest(info);
if(response.Result == XA_READONLY)
{
Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.transactionId);
this.transactionId = null;
this.currentEnlistment = null;
// Read Only means there's nothing to recover because there was no
// change on the broker.
RecoveryLogger.LogRecovered(this.transactionId as XATransactionId);
// if server responds that nothing needs to be done, then reply prepared
// but clear the current state data so we appear done to the commit method.
preparingEnlistment.Prepared();
// Done so commit won't be called.
AfterCommit();
}
else
{
Tracer.Debug("Transaction Prepare succeeded TX id: " + this.transactionId);
// If work finished correctly, reply prepared
preparingEnlistment.Prepared();
}
}
catch(Exception ex)
{
Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}",
this.transactionId, ex.Message);
AfterRollback();
preparingEnlistment.ForceRollback();
try
{
this.connection.OnException(ex);
}
catch (Exception error)
{
Tracer.Error(error.ToString());
}
this.currentEnlistment = null;
this.transactionId = null;
}
finally
{
this.dtcControlEvent.Set();
}
}
