internal void Begin()
{
try
{
if (_state == TransactionState.Active)
{
throw new InvalidOperationException("Transaction is already active");
}
CheckThread();
if (_threadFlag != null)
{
throw new InvalidOperationException("Nested transactions are not allowed!");
}
_threadFlag = true;
_startTime = Clock.CurrentTimeMillis();
var request = TransactionCreateCodec.EncodeRequest(GetTimeoutMillis(), _options.GetDurability(),
(int) _options.GetTransactionType(), _threadId);
var response = Invoke(request);
_txnId = TransactionCreateCodec.DecodeResponse(response).response;
_state = TransactionState.Active;
}
catch (Exception e)
{
_threadFlag = null;
throw ExceptionUtil.Rethrow(e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CqlBatchTransaction" /> class.
/// </summary>
public CqlBatchTransaction()
{
_batchCommand = new CqlCommand {Transaction = this};
_commands = new List<BatchFrame.BatchedCommand>();
_batchType = CqlBatchType.Logged;
_state = TransactionState.Pending;
}
public OutboundTransferModel GetOutsideTransferBySequenceNo(string seqNo, TransactionState txstate)
{
Check.Argument.IsNotEmpty(seqNo, "seqNo");
return this.Context.Sql(getOutboundTransferBySequenceNo_Sql)
.Parameter("@seqNo", seqNo)
.Parameter("@state", txstate)
.QuerySingle<OutboundTransferModel>();
}
private EquityTransaction(int shares, double priceBuy, double priceSell, DateTime dateBuy, DateTime dateSell, TransactionState state)
{
Shares = shares;
PriceBuy = priceBuy;
PriceSell = priceSell;
DateBuy = dateBuy;
DateSell = dateSell;
State = state;
}
public InsideTransferModel GetInsideTransferBySequenceNo(string seqNo, TransactionState txstate, CurrencyType currency)
{
Check.Argument.IsNotEmpty(seqNo, "seqNo");
return this.Context.Sql(getInsideTransferBySequenceNo_Sql.FormatWith(currency.ToString()))
.Parameter("@seqNo", seqNo)
.Parameter("@state", txstate)
.QuerySingle<InsideTransferModel>();
}
public TransactionCookie(int _transactionId, ILogger logImplement)
{
this._transactionId = _transactionId;
_keyResults = new Dictionary<string, string>();
_state = TransactionState._Unknown;
_transactionCompletedEvent = new ManualResetEvent(false);
_request = null;
_response = null;
_logger = logImplement;
}
public ExtTransaction(IDatabase db)
{
if (!(db is ExtDatabase))
{
throw new ArgumentException("Specified argument is not of FesDatabase type.");
}
_db = (ExtDatabase)db;
_state = TransactionState.NoTransaction;
_statusVector = new int[IscCodes.ISC_STATUS_LENGTH];
}
public GdsTransaction(IDatabase db)
: this()
{
if (!(db is GdsDatabase))
{
throw new ArgumentException("Specified argument is not of GdsDatabase type.");
}
_database = (GdsDatabase)db;
_state = TransactionState.NoTransaction;
}
public FesTransaction(IDatabase db)
{
if (!(db is FesDatabase))
{
throw new ArgumentException("Specified argument is not of FesDatabase type.");
}
this.db = (FesDatabase)db;
this.state = TransactionState.NoTransaction;
GC.SuppressFinalize(this);
}
public FesTransaction(IDatabase db)
{
if (!(db is FesDatabase))
{
throw new ArgumentException("Specified argument is not of FesDatabase type.");
}
this.db = (FesDatabase)db;
this.state = TransactionState.NoTransaction;
this.statusVector = new IntPtr[IscCodes.ISC_STATUS_LENGTH];
GC.SuppressFinalize(this);
}
private DataServiceTransaction(DataService dataService) {
_transactionState = TransactionState.Active;
_dataService = dataService;
_sendMessagesToPeers = true;
_rollbackOnly = false;
_outgoingMessages = new ArrayList();
_processedMessageBatches = new ArrayList(1);
#if (NET_1_1)
_updateCollectionMessages = new Hashtable(new ListHashCodeProvider(), new ListComparer());
_clientUpdateCollectionMessages = new Hashtable(new ListHashCodeProvider(), new ListComparer());
#else
_updateCollectionMessages = new Hashtable(new ListHashCodeProvider());
_clientUpdateCollectionMessages = new Hashtable(new ListHashCodeProvider());
#endif
}
/// <summary>
/// Creates a new transaction having the given parameters.
/// </summary>
/// <param name="myDistributed">Indicates that this transaction should synched within the entire cluster.</param>
/// <param name="myLongRunning">Indicates that this transaction is a long-running transaction.</param>
/// <param name="myIsolationLevel">The isolation level of this transaction.</param>
/// <param name="myName">A name or identification for this transaction.</param>
/// <param name="myCreated"></param>
/// <param name="myTransactionUUID"></param>
public ATransaction(Boolean myDistributed = false, Boolean myLongRunning = false, IsolationLevel myIsolationLevel = IsolationLevel.Serializable, String myName = "", DateTime? myCreated = null, TransactionUUID myTransactionUUID = null)
{
UUID = TransactionUUID.NewUUID;
_State = TransactionState.Running;
if (myCreated.HasValue)
Created = myCreated.Value;
else
Created = TimestampNonce.Now;
IsolationLevel = myIsolationLevel;
Distributed = myDistributed;
LongRunning = myLongRunning;
Name = myName;
}
public bool Delete(AccountClass account)
{
bool bResult = false;
try
{
using (DbManager db = new DbManager())
{
Accessor.Query.Delete(db, account);
}
bResult = true;
}
catch (Exception except)
{
throw new System.ArgumentException(except.Message);
}
TransState = TransactionState.Default;
return bResult;
}
public void TestGetBlock()
{
var snapshot = TestBlockchain.GetTestSnapshot();
var tx1 = TestUtils.GetTransaction(UInt160.Zero);
tx1.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01 };
var state1 = new TransactionState
{
Transaction = tx1,
BlockIndex = 1
};
var tx2 = TestUtils.GetTransaction(UInt160.Zero);
tx2.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x02 };
var state2 = new TransactionState
{
Transaction = tx2,
BlockIndex = 1
};
UT_SmartContractHelper.TransactionAdd(snapshot, state1, state2);
TrimmedBlock tblock = GetTrimmedBlockWithNoTransaction();
tblock.Hashes = new UInt256[] { tx1.Hash, tx2.Hash };
UT_SmartContractHelper.BlocksAdd(snapshot, tblock.Hash, tblock);
Block block = NativeContract.Ledger.GetBlock(snapshot, tblock.Hash);
block.Index.Should().Be(1);
block.MerkleRoot.Should().Be(UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff02"));
block.Transactions.Length.Should().Be(2);
block.Transactions[0].Hash.Should().Be(tx1.Hash);
block.Witness.InvocationScript.ToHexString().Should().Be(tblock.Header.Witness.InvocationScript.ToHexString());
block.Witness.VerificationScript.ToHexString().Should().Be(tblock.Header.Witness.VerificationScript.ToHexString());
}
internal DB2Transaction(DB2Connection con, IsolationLevel isoL)
{
long db2IsoL;
connection = con;
short sqlRet;
isolationLevel = isoL;
switch (isoL)
{
default:
case System.Data.IsolationLevel.Chaos: //No DB2equivalent, default to SQL_TXN_READ_COMMITTED
case System.Data.IsolationLevel.ReadCommitted: //SQL_TXN_READ_COMMITTED
db2IsoL = DB2Constants.SQL_TXN_READ_COMMITTED;
break;
case System.Data.IsolationLevel.ReadUncommitted: //SQL_TXN_READ_UNCOMMITTED
db2IsoL = DB2Constants.SQL_TXN_READ_UNCOMMITTED;
break;
case System.Data.IsolationLevel.RepeatableRead: //SQL_TXN_REPEATABLE_READ
db2IsoL = DB2Constants.SQL_TXN_REPEATABLE_READ;
break;
case System.Data.IsolationLevel.Serializable: //SQL_TXN_SERIALIZABLE_READ
db2IsoL = DB2Constants.SQL_TXN_SERIALIZABLE_READ;
break;
}
//AutoCommit
if (connection.AutoCommit)
{
sqlRet = DB2CLIWrapper.SQLSetConnectAttr(connection.DBHandle, DB2Constants.SQL_ATTR_AUTOCOMMIT, new IntPtr(DB2Constants.SQL_AUTOCOMMIT_OFF), 0);
DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, connection.DBHandle, "Error setting AUTOCOMMIT OFF in transaction CTOR.", connection);
connection.AutoCommit = false;
}
sqlRet = DB2CLIWrapper.SQLSetConnectAttr(connection.DBHandle, DB2Constants.SQL_ATTR_TXN_ISOLATION, new IntPtr(db2IsoL), 0);
DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, connection.DBHandle, "Error setting isolation level.", connection);
state = TransactionState.Open;
}
public override void Rollback()
{
EnsureActiveTransactionState();
lock (_db)
{
// Clear the status vector
ClearStatusVector();
_db.FbClient.isc_rollback_transaction(_statusVector, ref _handle);
_db.ProcessStatusVector(_statusVector);
_db.TransactionCount--;
Update?.Invoke(this, new EventArgs());
_state = TransactionState.NoTransaction;
}
}
public void Discard()
{
if (transactionState != TransactionState.OK)
{
return;
}
transactionState = TransactionState.Aborted;
if (!hasMutated)
{
return;
}
context.Aborted = true;
try {
client.Discard(context);
} catch (RpcException) { }
}
void IDisposable.Dispose()
{
var currentState = this.state;
if (currentState == TransactionState.Disposing)
{
return;
}
this.state = TransactionState.Disposing;
if (currentState != TransactionState.Committed)
{
this.actions.Rollback(exceptionHandler);
}
if (this.scope != null)
{
using (scope) { }
}
}
private void SetupInvite(IRequest request)
{
_state = TransactionState.Calling;
_transportManager.Send(_endPoint, request);
_request = request;
// If an unreliable transport is being used, the client transaction MUST
// start timer A with a value of T1. If a reliable transport is being used,
// the client transaction SHOULD NOT start timer A
if (request.Via.First.Protocol == "UDP")
{
_timerAValue = TransactionManager.T1;
_timerA = new Timer(OnRetransmission, null, _timerAValue, Timeout.Infinite);
}
// For any transport, the client transaction MUST start timer B with a value of 64*T1 seconds
_timerB = new Timer(OnTimeout, null, TransactionManager.T1 * 64, Timeout.Infinite);
_timerD = new Timer(OnTerminate, null, _timerDValue, Timeout.Infinite);
}
public void RequestChange()
{
if (state == TransactionState.PreInitialize)
{
return;
}
if (state == TransactionState.InTransactionNoChangeNeeded)
{
state = TransactionState.InTransactionChangeNeeded;
}
else if (state == TransactionState.OutsideTransactionNoChangeNeeded)
{
change();
}
else if (state == TransactionState.AfterTransactionChanging)
{
throw new InvalidOperationException("Circular change condition detected");
}
}
/// <summary>
/// Commits the underlying EF transaction
/// </summary>
public void Complete()
{
switch (_transactionState)
{
case TransactionState.Open:
_dbContextTransaction.Commit();
_transactionState = TransactionState.Commited;
break;
case TransactionState.RolledBack:
throw new ChildTransactionRolledBackException("Cannot complete the transaction because the transaction has already been rolled back by a child scope");
case TransactionState.Closed:
case TransactionState.Commited:
throw new InvalidOperationException("Cannot complete the transaction because the transaction is already " + _transactionState.ToString().ToLower());
default:
throw new NotImplementedException("Unrecognised TransactionState: " + _transactionState);
}
}
public TransactionInfo Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
{
rlpStream.ReadSequenceLength();
try
{
Keccak hash = rlpStream.DecodeKeccak();
UInt256 value = rlpStream.DecodeUInt256();
UInt256 gasPrice = rlpStream.DecodeUInt256();
ulong gasLimit = rlpStream.DecodeUlong();
ulong timestamp = rlpStream.DecodeUlong();
TransactionType type = (TransactionType)rlpStream.DecodeInt();
TransactionState state = (TransactionState)rlpStream.DecodeInt();
return(new TransactionInfo(hash, value, gasPrice, gasLimit, timestamp, type, state));
}
catch (Exception e)
{
throw new RlpException($"{nameof(TransactionInfo)} could not be decoded", e);
}
}
public void TestShutdown()
{
LocalTransactionId id = new LocalTransactionId();
id.Value = 42;
TransactionState state = new TransactionState(id);
state.AddCommand(new Message());
state.AddCommand(new Message());
state.AddCommand(new Message());
state.AddCommand(new Message());
state.AddProducer(new ProducerState(CreateProducerInfo(1)));
state.AddProducer(new ProducerState(CreateProducerInfo(2)));
Assert.AreEqual(4, state.Commands.Count);
Assert.AreEqual(2, state.ProducerStates.Count);
state.Shutdown();
Assert.AreEqual(0, state.Commands.Count);
Assert.AreEqual(0, state.ProducerStates.Count);
try
{
state.AddCommand(new Message());
Assert.Fail("Should have thrown an exception");
}
catch
{
}
try
{
state.AddProducer(new ProducerState(CreateProducerInfo(2)));
Assert.Fail("Should have thrown an exception");
}
catch
{
}
}
internal void AdvanceState(TransactionState nextState)
{
switch (nextState)
{
case TransactionState.None:
throw CreateTransitionException((TransactionState)_transactionLogState, TransactionState.None);
case TransactionState.Active:
{
var orig = (TransactionState)Interlocked.CompareExchange(ref _transactionLogState, (int)TransactionState.Active, (int)TransactionState.None);
if (orig != TransactionState.None)
{
throw CreateTransitionException(orig, TransactionState.Active);
}
return;
}
case TransactionState.Deleting:
{
var orig = (TransactionState)Interlocked.CompareExchange(ref _transactionLogState, (int)TransactionState.Deleting, (int)TransactionState.Active);
if (orig != TransactionState.Active)
{
throw CreateTransitionException(orig, TransactionState.Deleting);
}
return;
}
case TransactionState.Deleted:
{
var orig = (TransactionState)Interlocked.CompareExchange(ref _transactionLogState, (int)TransactionState.Deleted, (int)TransactionState.Deleting);
if (orig != TransactionState.Deleting)
{
throw CreateTransitionException(orig, TransactionState.Deleted);
}
return;
}
default:
throw new InvalidOperationException();
}
}
public override async Task RollbackRetaining(AsyncWrappingCommonArgs async)
{
EnsureActiveTransactionState();
try
{
await _database.Xdr.Write(IscCodes.op_rollback_retaining, async).ConfigureAwait(false);
await _database.Xdr.Write(_handle, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await _database.ReadResponse(async).ConfigureAwait(false);
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
/// <summary>
/// Rolls back the transaction.
/// </summary>
/// <remarks>
/// This is internal because it is only intended to be called by a ChildTransactionScope
/// </remarks>
internal void Rollback()
{
switch (_transactionState)
{
case TransactionState.Open:
_dbContextTransaction.Rollback();
_transactionState = TransactionState.RolledBack;
break;
case TransactionState.RolledBack:
// The transaction has already been rolled back
break;
case TransactionState.Closed:
case TransactionState.Commited:
throw new InvalidOperationException("Cannot rollback the transaction because the transaction is already " + _transactionState.ToString().ToLower());
default:
throw new NotImplementedException("Unrecognised TransactionState: " + _transactionState);
}
}
public void Initialize()
{
origin = new TransactionState
{
BlockIndex = 1,
Transaction = new Transaction()
{
Attributes = Array.Empty <TransactionAttribute>(),
Script = new byte[] { (byte)OpCode.PUSH1 },
Signers = new Signer[] { new Signer()
{
Account = UInt160.Zero
} },
Witnesses = new Witness[] { new Witness()
{
InvocationScript = Array.Empty <byte>(),
VerificationScript = Array.Empty <byte>()
} }
}
};
}
public override void Prepare()
{
EnsureActiveTransactionState();
try
{
_state = TransactionState.NoTransaction;
_database.Xdr.Write(IscCodes.op_prepare);
_database.Xdr.Write(_handle);
_database.Xdr.Flush();
_database.ReadResponse();
_state = TransactionState.Prepared;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public static NeoSystem InitializeMockNeoSystem()
{
if (TheNeoSystem == null)
{
var mockSnapshot = new Mock <Snapshot>();
mockSnapshot.SetupGet(p => p.Blocks).Returns(new TestDataCache <UInt256, TrimmedBlock>());
mockSnapshot.SetupGet(p => p.Transactions).Returns(new TestDataCache <UInt256, TransactionState>());
mockSnapshot.SetupGet(p => p.Contracts).Returns(new TestDataCache <UInt160, ContractState>());
mockSnapshot.SetupGet(p => p.Storages).Returns(new TestDataCache <StorageKey, StorageItem>());
mockSnapshot.SetupGet(p => p.HeaderHashList).Returns(new TestDataCache <UInt32Wrapper, HeaderHashList>());
mockSnapshot.SetupGet(p => p.BlockHashIndex).Returns(new TestMetaDataCache <HashIndexState>());
mockSnapshot.SetupGet(p => p.HeaderHashIndex).Returns(new TestMetaDataCache <HashIndexState>());
_Store = new Mock <Store>();
var defaultTx = TestUtils.CreateRandomHashTransaction();
var txState = new TransactionState
{
BlockIndex = 1,
Transaction = defaultTx
};
_Store.Setup(p => p.GetBlocks()).Returns(new TestDataCache <UInt256, TrimmedBlock>());
_Store.Setup(p => p.GetTransactions()).Returns(new TestDataCache <UInt256, TransactionState>(defaultTx.Hash, txState));
_Store.Setup(p => p.GetContracts()).Returns(new TestDataCache <UInt160, ContractState>());
_Store.Setup(p => p.GetStorages()).Returns(new TestDataCache <StorageKey, StorageItem>());
_Store.Setup(p => p.GetHeaderHashList()).Returns(new TestDataCache <UInt32Wrapper, HeaderHashList>());
_Store.Setup(p => p.GetBlockHashIndex()).Returns(new TestMetaDataCache <HashIndexState>());
_Store.Setup(p => p.GetHeaderHashIndex()).Returns(new TestMetaDataCache <HashIndexState>());
_Store.Setup(p => p.GetSnapshot()).Returns(mockSnapshot.Object);
Console.WriteLine("initialize NeoSystem");
TheNeoSystem = new NeoSystem(_Store.Object); // new Mock<NeoSystem>(mockStore.Object);
// Ensure that blockchain is loaded
var blockchain = Blockchain.Singleton;
}
return(TheNeoSystem);
}
public void TestGetBlock()
{
var cache = new TestDataCache <UInt256, TransactionState>();
var tx1 = TestUtils.GetTransaction();
tx1.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01 };
var state1 = new TransactionState
{
Transaction = tx1,
BlockIndex = 1
};
var tx2 = TestUtils.GetTransaction();
tx2.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x02 };
var state2 = new TransactionState
{
Transaction = tx2,
BlockIndex = 1
};
cache.Add(tx1.Hash, state1);
cache.Add(tx2.Hash, state2);
TrimmedBlock tblock = GetTrimmedBlockWithNoTransaction();
tblock.Hashes = new UInt256[] { tx1.Hash, tx2.Hash };
Block block = tblock.GetBlock(cache);
block.Index.Should().Be(1);
block.MerkleRoot.Should().Be(UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff02"));
block.Transactions.Length.Should().Be(1);
block.Transactions[0].Hash.Should().Be(tx2.Hash);
}
public void RollbackRetaining()
{
this.CheckTransactionState();
lock (this.database.SyncObject)
{
try
{
this.database.Write(IscCodes.op_rollback_retaining);
this.database.Write(this.handle);
this.database.Flush();
this.database.ReadResponse();
this.state = TransactionState.Active;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void Initialize()
{
origin = new TransactionState
{
BlockIndex = 1,
VMState = VM.VMState.NONE,
Transaction = new Neo.Network.P2P.Payloads.Transaction()
{
Attributes = Array.Empty <TransactionAttribute>(),
Script = new byte[] { 0x01 },
Signers = new Signer[] { new Signer()
{
Account = UInt160.Zero
} },
Witnesses = new Witness[] { new Witness()
{
InvocationScript = Array.Empty <byte>(),
VerificationScript = Array.Empty <byte>()
} }
}
};
}
public void TestBlockchain_GetTransactionHeight()
{
var engine = GetEngine(hasSnapshot: true, addScript: false);
var state = new TransactionState()
{
BlockIndex = 0,
Transaction = TestUtils.CreateRandomHashTransaction()
};
UT_SmartContractHelper.TransactionAdd(engine.Snapshot, state);
using var script = new ScriptBuilder();
script.EmitDynamicCall(NativeContract.Ledger.Hash, "getTransactionHeight", state.Transaction.Hash);
engine.LoadScript(script.ToArray());
engine.Execute();
Assert.AreEqual(engine.State, VMState.HALT);
var result = engine.ResultStack.Pop();
result.Should().BeOfType(typeof(VM.Types.Integer));
result.GetInteger().Should().Be(0);
}
public WidControlPOSTransaction()
{
clReceiptManager = null;
clMode = General.ParseEnum <POSReceiptManager.ReceiptType>(ApplicationFrame.GetInstance().ActiveFormInfoManager.GetFormParam(ctFPMReceiptType), POSReceiptManager.ReceiptType.Sale);
clEdition = ApplicationFrame.GetInstance().ActiveSubscription.GetEdition();
clLanguageManager = ApplicationFrame.GetInstance().ActiveSubscription.ActiveLanguage;
clSettingManager = ApplicationFrame.GetInstance().ActiveSubscription.ActiveSetting;
clAdminUser = ApplicationFrame.GetInstance().ActiveSessionController.User.IsAdminUser();
clTransactionSetting = General.JSONDeserialize <Dictionary <String, String> >(clSettingManager.GetSettingValue(ctSETTransactionSetting));
clReceiptPrintMode = clTransactionSetting.GetData(ctKEYReceiptPrintOption, String.Empty).Contains(clMode.ToString().ToLower());
clShowPaymentForm = General.ParseBoolean(clTransactionSetting.GetData(ctKEYShowPaymentForm), false);
//clTaxApplicable = General.ParseBoolean(clTransactionSetting.GetData(ctKEYTaxApplicable), false);
//clTaxPercent = General.ParseDecimal(clTransactionSetting.GetData(ctKEYTaxApplicable),0);
//clMultiPaymentMode = clTransactionOption.GetData(ctKEYMultiPaymentMode, String.Empty).Contains(clMode.ToString().ToLower());
//clReceiptPrintMode = clTransactionOption.GetData(ctKEYReceiptPrintMode, String.Empty).Contains(clMode.ToString().ToLower());
clTransactionState = General.ParseEnum <TransactionState>(ApplicationFrame.GetInstance().ActiveFormInfoManager.GetFormParam(ctFPMTransactionState), TransactionState.Normal);
clFormTitle = ApplicationFrame.GetInstance().ActiveFormInfoManager.GetFormParam(ctFPMFormTitle, String.Empty);
}
protected async Task StoreImpactedRecordsInDataEventTransaction(TransactionState transactionState, DataEventTransaction dataEventTransaction)
{
foreach (var dynamicView in this.dynamicViews)
{
foreach (var dataEvent in dataEventTransaction.dataEvents)
{
if (dataEvent is KeyValueDataEvent keyValueDataEvent && dynamicView.TryGetDynamicStatementFromRef(keyValueDataEvent.name, out StatementFromRef dynamicStatementFromRef))
{
if (HasImpactedRecords(transactionState, keyValueDataEvent, dynamicStatementFromRef.joinType))
{
Dict[] impactedRecords = await dynamicView.GetImpactedRecordsAsync(keyValueDataEvent);
if (impactedRecords != null && impactedRecords.Length > 0)
{
string storageKey = GetImpactedRecordsStorageKey(dynamicView, dataEvent, transactionState);
dataEventTransaction.Store(storageKey, impactedRecords);
}
}
}
}
}
}
private void RecordTransactionInfo()
{
TransactionState.Duration = _duration;
string transactionType = "Other";
object eventSourceArnTag = GetTag("aws.lambda.eventSource.arn");
var s = eventSourceArnTag as string;
string eventSourceArn = s != null ? s : "";
if (eventSourceArn.StartsWith("arn:aws:iam") || eventSourceArn.StartsWith("arn:aws:elasticloadbalancing"))
{
transactionType = "WebTransaction";
}
string arn = (string)GetTag("aws.arn");
if (arn != null && arn.Contains(":"))
{
TransactionState.SetTransactionName(transactionType, arn.Substring(arn.LastIndexOf(":", StringComparison.CurrentCulture) + 1));
}
}
public void Commit()
{
lock (this.db)
{
if (this.state != TransactionState.TransactionStarted &&
this.state != TransactionState.TransactionPrepared)
{
throw new IscException(
IscCodes.isc_arg_gds,
IscCodes.isc_tra_state,
this.handle,
"no valid");
}
this.state = TransactionState.TransactionCommiting;
try
{
this.db.Send.Write(IscCodes.op_commit);
this.db.Send.Write(this.handle);
this.db.Send.Flush();
this.db.ReadGenericResponse();
this.db.TransactionCount--;
if (this.Update != null)
{
this.Update(this, new EventArgs());
}
this.state = TransactionState.NoTransaction;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public BitTransaction(int tIndex)
{
SQLRow[] SR = MarketInterface.ExecReader("SELECT * FROM BitTransaction WHERE ID=?", new object[] { tIndex });
if (SR != null && SR.Length > 0)
{
Index = tIndex;
_addrBuyer = SR[0].Values["AddressBuyer"].ToString();
_addrSeller = SR[0].Values["AddressSeller"].ToString();
_amount = (int)SR[0].Values["Amount"];
_offer = (int)SR[0].Values["Offer"];
_state = (TransactionState)(int)SR[0].Values["State"];
_buyerComment = SR[0].Values["BuyerComment"].ToString();
_sellerComment = SR[0].Values["SellerComment"].ToString();
_buyerRating = (Rating)(int)SR[0].Values["BuyerRating"];
_sellerRating = (Rating)(int)SR[0].Values["SellerRating"];
_transactionTime = (DateTime)SR[0].Values["TransactionTime"];
}
else
{
throw new Exception("Invalid Index");
}
}
public override void Prepare(byte[] buffer)
{
EnsureActiveTransactionState();
try
{
_state = TransactionState.NoTransaction;
_database.XdrStream.Write(IscCodes.op_prepare2);
_database.XdrStream.Write(_handle);
_database.XdrStream.WriteBuffer(buffer, buffer.Length);
_database.XdrStream.Flush();
_database.ReadResponse();
_state = TransactionState.Prepared;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
/**
* Possible state changes
*
* Default -> Constructed
* Constructed -> Disposed
* Constructed -> Active
* Active -> CommittedOrCompleted (depends on whether we are committable or not)
* Active -> InDoubt
* Active -> Aborted
* Aborted -> Disposed # an active transaction may be disposed and then dispose must take take of aborting
*/
void ITransaction.Dispose()
{
try
{
try
{
if (_State == TransactionState.Active)
{
InnerRollback();
}
}
finally
{
// the question is; does committable transaction object to being disposed on exceptions?
((IDisposable)this).Dispose();
}
}
finally
{
_State = TransactionState.Disposed;
}
}
protected virtual void Dispose(bool isManaged)
{
if (!isManaged)
{
return;
}
_Logger.LogDebug("disposing");
_DependentTasks?.Clear();
try
{
_OnDispose?.Invoke();
Inner.Dispose();
}
finally
{
_State = TransactionState.Disposed;
}
}
/// <inheritdoc />
public async Task RollbackAsync()
{
if (State == TransactionState.RollingBack)
{
State = TransactionState.RolledBack;
return;
}
if (State != TransactionState.Active)
{
throw new InvalidOperationException("There is no active transaction to roll back.");
}
if (_threadId != ContextId)
{
HConsole.WriteLine(this, $"Rollback transaction on context #{ContextId} that was started on #{_threadId}");
throw new InvalidOperationException("Transactions cannot span multiple async contexts.");
}
HConsole.WriteLine(this, $"Rollback transaction on context #{ContextId}");
try
{
var requestMessage = TransactionRollbackCodec.EncodeRequest(TransactionId, ContextId);
var responseMessage = await _cluster.Messaging.SendToMemberAsync(requestMessage, _connection).CfAwait();
_ = TransactionRollbackCodec.DecodeResponse(responseMessage);
State = TransactionState.RolledBack;
}
catch
{
// TODO: that is the original code - weird
State = TransactionState.RolledBack;
}
finally
{
lock (_inTransactionMutex) AsyncContext.Current.InTransaction = false;
}
}
public void TestGetBlock()
{
var snapshot = Blockchain.Singleton.GetSnapshot();
var tx1 = TestUtils.GetTransaction();
tx1.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01 };
var state1 = new TransactionState
{
Transaction = tx1,
BlockIndex = 1
};
var tx2 = TestUtils.GetTransaction();
tx2.Script = new byte[] { 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x02 };
var state2 = new TransactionState
{
Transaction = tx2,
BlockIndex = 1
};
snapshot.Transactions.Add(tx1.Hash, state1);
snapshot.Transactions.Add(tx2.Hash, state2);
TrimmedBlock tblock = GetTrimmedBlockWithNoTransaction();
tblock.Hashes = new UInt256[] { tx1.Hash, tx2.Hash };
Block block = tblock.GetBlock(snapshot.Transactions);
block.Index.Should().Be(1);
block.MerkleRoot.Should().Be(UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff02"));
block.Transactions.Length.Should().Be(1);
block.Transactions[0].Hash.Should().Be(tx2.Hash);
}
internal DB2Transaction(DB2Connection con, IsolationLevel isoL)
{
long db2IsoL;
db2Conn = con;
short sqlRet;
isolationLevel = isoL;
switch (isoL)
{
default:
case System.Data.IsolationLevel.Chaos: //No DB2equivalent, default to SQL_TXN_READ_COMMITTED
case System.Data.IsolationLevel.ReadCommitted: //SQL_TXN_READ_COMMITTED
db2IsoL = DB2Constants.SQL_TXN_READ_COMMITTED;
break;
case System.Data.IsolationLevel.ReadUncommitted: //SQL_TXN_READ_UNCOMMITTED
db2IsoL = DB2Constants.SQL_TXN_READ_UNCOMMITTED;
break;
case System.Data.IsolationLevel.RepeatableRead: //SQL_TXN_REPEATABLE_READ
db2IsoL = DB2Constants.SQL_TXN_REPEATABLE_READ;
break;
case System.Data.IsolationLevel.Serializable: //SQL_TXN_SERIALIZABLE_READ
db2IsoL = DB2Constants.SQL_TXN_SERIALIZABLE_READ;
break;
}
if(db2Conn.openConnection.autoCommit)
{
sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_AUTOCOMMIT, new IntPtr(DB2Constants.SQL_AUTOCOMMIT_OFF), 0);
DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting AUTOCOMMIT OFF in transaction CTOR.", db2Conn);
db2Conn.openConnection.autoCommit = false;
}
sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_TXN_ISOLATION, new IntPtr(db2IsoL), 0);
DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting isolation level.", db2Conn);
state = TransactionState.Open;
}
public void RollbackRetaining()
{
lock (stateSyncRoot)
{
this.CheckTransactionState();
try
{
lock (this.database.SyncObject)
{
this.database.Write(IscCodes.op_rollback_retaining);
this.database.Write(this.handle);
this.database.Flush();
this.database.ReadResponse();
}
this.state = TransactionState.Active;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void Rollback()
{
lock (stateSyncRoot)
{
this.CheckTransactionState();
try
{
lock (this.database.SyncObject)
{
this.database.Write(IscCodes.op_rollback);
this.database.Write(this.handle);
this.database.Flush();
this.database.ReadResponse();
this.database.TransactionCount--;
}
if (this.Update != null)
{
this.Update(this, new EventArgs());
}
this.state = TransactionState.NoTransaction;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
lock (stateSyncRoot)
{
if (this.state != TransactionState.NoTransaction)
{
throw GetNoValidTransactionException();
}
try
{
GenericResponse response;
lock (this.database.SyncObject)
{
this.database.Write(IscCodes.op_transaction);
this.database.Write(this.database.Handle);
this.database.WriteBuffer(tpb.ToArray());
this.database.Flush();
response = this.database.ReadGenericResponse();
this.database.TransactionCount++;
}
this.handle = response.ObjectHandle;
this.state = TransactionState.Active;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
/// <summary>
/// Rollsback this transaction.
/// You should only use this method if you created the DataServiceTransaction with the Begin method.
/// </summary>
public void Rollback()
{
try
{
}
finally
{
_transactionState = TransactionState.RolledBack;
}
}
/// <summary>
/// Clients can call this method to commit the transaction. You should only use this method if
/// you used the begin method to create the DataServiceTransaction.
/// Otherwise, the gateway will commit or rollback the transaction as necessary.
/// </summary>
public void Commit()
{
if( _rollbackOnly )
{
Rollback();
return;
}
try
{
ProcessRefreshFills();
_pushMessages = new ArrayList();
for(int i = 0; i < _processedMessageBatches.Count; i++)
{
MessageBatch messageBatch = _processedMessageBatches[i] as MessageBatch;
if( messageBatch.Messages != null && messageBatch.Messages.Count > 0 )
{
DataDestination dataDestination = _dataService.GetDestination(messageBatch.IncomingMessage) as DataDestination;
try
{
dataDestination.SequenceManager.ManageMessageBatch(messageBatch, this);
}
catch(Exception ex)
{
MessageException messageException = new MessageException(ex);
ErrorMessage errorMessage = messageException.GetErrorMessage();
errorMessage.correlationId = messageBatch.IncomingMessage.messageId;
errorMessage.destination = messageBatch.IncomingMessage.destination;
messageBatch.Messages.Clear();
messageBatch.Messages.Add(errorMessage);
}
for(int j = 0; j < messageBatch.Messages.Count; j++)
{
IMessage message = messageBatch.Messages[j] as IMessage;
if( !(message is ErrorMessage) )
_pushMessages.Add(message);
}
}
_outgoingMessages.AddRange(messageBatch.Messages);
}
for(int i = 0; i < _pushMessages.Count; i++)
{
IMessage message = _pushMessages[i] as IMessage;
DataMessage dataMessage = message as DataMessage;
if( dataMessage != null )
PushMessage(GetSubscribers(message), message);
}
foreach(DictionaryEntry entry in _clientUpdateCollectionMessages)
{
UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage;
_outgoingMessages.Add(updateCollectionMessage);
PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage);
}
foreach(DictionaryEntry entry in _updateCollectionMessages)
{
UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage;
_outgoingMessages.Add(updateCollectionMessage);
PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage);
}
}
finally
{
_transactionState = TransactionState.Committed;
}
}
internal void Activate()
{
_transactionState = TransactionState.Active;
}
public void BeginTransaction ()
{
if (transaction_state == TransactionState.None)
transaction_state = TransactionState.Requested;
}
public void Prepare(byte[] buffer)
{
lock (_stateSyncRoot)
{
CheckTransactionState();
try
{
_state = TransactionState.NoTransaction;
lock (_database.SyncObject)
{
_database.XdrStream.Write(IscCodes.op_prepare2);
_database.XdrStream.Write(_handle);
_database.XdrStream.WriteBuffer(buffer, buffer.Length);
_database.XdrStream.Flush();
_database.ReadResponse();
}
_state = TransactionState.Prepared;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void RollbackRetaining()
{
lock (_stateSyncRoot)
{
CheckTransactionState();
try
{
lock (_database.SyncObject)
{
_database.XdrStream.Write(IscCodes.op_rollback_retaining);
_database.XdrStream.Write(_handle);
_database.XdrStream.Flush();
_database.ReadResponse();
}
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void Rollback()
{
lock (_stateSyncRoot)
{
CheckTransactionState();
try
{
lock (_database.SyncObject)
{
_database.XdrStream.Write(IscCodes.op_rollback);
_database.XdrStream.Write(_handle);
_database.XdrStream.Flush();
_database.ReadResponse();
_database.TransactionCount--;
}
if (Update != null)
{
Update(this, new EventArgs());
}
_state = TransactionState.NoTransaction;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
lock (_stateSyncRoot)
{
if (_state != TransactionState.NoTransaction)
{
throw GetNoValidTransactionException();
}
try
{
GenericResponse response;
lock (_database.SyncObject)
{
_database.XdrStream.Write(IscCodes.op_transaction);
_database.XdrStream.Write(_database.Handle);
_database.XdrStream.WriteBuffer(tpb.ToArray());
_database.XdrStream.Flush();
response = _database.ReadGenericResponse();
_database.TransactionCount++;
}
_handle = response.ObjectHandle;
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
internal void Completed(TransactionState transactionState)
{
Debug.Assert(TransactionState.Active < transactionState, "invalid transaction completion state?");
_transactionState = transactionState;
Zombie();
}
public void Prepare(byte[] buffer)
{
lock (stateSyncRoot)
{
this.CheckTransactionState();
try
{
this.state = TransactionState.NoTransaction;
lock (this.database.SyncObject)
{
this.database.Write(IscCodes.op_prepare2);
this.database.Write(this.handle);
this.database.WriteBuffer(buffer, buffer.Length);
this.database.Flush();
this.database.ReadResponse();
}
this.state = TransactionState.Prepared;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
private void Dispose(bool disposing)
{
lock (_stateSyncRoot)
{
if (!_disposed)
{
try
{
Rollback();
}
catch
{ }
finally
{
if (disposing)
{
_database = null;
_handle = 0;
_state = TransactionState.NoTransaction;
}
_disposed = true;
}
}
}
}
private void Dispose(bool disposing)
{
lock (stateSyncRoot)
{
if (!this.disposed)
{
try
{
// release any unmanaged resources
this.Rollback();
}
catch
{
}
finally
{
// release any managed resources
if (disposing)
{
this.database = null;
this.handle = 0;
this.state = TransactionState.NoTransaction;
}
this.disposed = true;
}
}
}
}
public void CommitTransaction ()
{
if (transaction_state == TransactionState.Started) {
lock (connection)
SqliteUtils.DoNonQuery (connection, "COMMIT");
}
transaction_state = TransactionState.None;
}
