コード例 #1
0
ファイル: TransactionScopeTest.cs プロジェクト: dotnet/corefx
        public void ExplicitTransaction1()
        {
            Assert.Null(Transaction.Current);
            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;

            Transaction.Current = ct;
            try
            {
                IntResourceManager irm = new IntResourceManager(1);

                irm.Value = 2;

                using (TransactionScope scope = new TransactionScope())
                {
                    Assert.Equal(ct, Transaction.Current);
                    irm.Value = 4;
                    scope.Complete();
                }

                Assert.Equal(ct, Transaction.Current);
                Assert.Equal(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status);
                Assert.Equal(1, irm.Actual);

                ct.Commit();
                Assert.Equal(4, irm.Actual);
                Assert.Equal(TransactionStatus.Committed, Transaction.Current.TransactionInformation.Status);
            }
            finally
            {
                Transaction.Current = oldTransaction;
            }
        }
コード例 #2
0
ファイル: CloneTxTests.cs プロジェクト: krytarowski/corefx
        // TODO: Issue #10353 - These variations need to be added once we have promotion support.
        /*
        [InlineData(CloneType.Normal, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.RepeatableRead, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.ReadCommitted, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.ReadUncommitted, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Snapshot, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Chaos, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Unspecified, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
        */
        public void Run(CloneType cloneType, IsolationLevel isoLevel, bool forcePromote, bool completeClone, TransactionStatus expectedStatus )
        {
            TransactionOptions options = new TransactionOptions
            {
                IsolationLevel = isoLevel,
                // Shorten the delay before a timeout for blocking clones.
                Timeout = TimeSpan.FromSeconds(1)
            };

            CommittableTransaction tx = new CommittableTransaction(options);

            Transaction clone;
            switch (cloneType)
            {
                case CloneType.Normal:
                    {
                        clone = tx.Clone();
                        break;
                    }
                case CloneType.BlockingDependent:
                    {
                        clone = tx.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
                        break;
                    }
                case CloneType.RollbackDependent:
                    {
                        clone = tx.DependentClone(DependentCloneOption.RollbackIfNotComplete);
                        break;
                    }
                default:
                    {
                        throw new Exception("Unexpected CloneType - " + cloneType.ToString());
                    }
            }

            if (forcePromote)
            {
                HelperFunctions.PromoteTx(tx);
            }

            Assert.Equal(clone.IsolationLevel, tx.IsolationLevel);
            Assert.Equal(clone.TransactionInformation.Status, tx.TransactionInformation.Status);
            Assert.Equal(clone.TransactionInformation.LocalIdentifier, tx.TransactionInformation.LocalIdentifier);
            Assert.Equal(clone.TransactionInformation.DistributedIdentifier, tx.TransactionInformation.DistributedIdentifier);

            CommittableTransaction cloneCommittable = clone as CommittableTransaction;
            Assert.Null(cloneCommittable);

            try
            {
                tx.Commit();
            }
            catch (TransactionAbortedException)
            {
                Assert.Equal(expectedStatus, TransactionStatus.Aborted);
            }

            Assert.Equal(expectedStatus, tx.TransactionInformation.Status);
        }
コード例 #3
0
ファイル: AsyncTest.cs プロジェクト: geoffkizer/corefx
        public void AsyncFail1()
        {
            Assert.Throws<InvalidOperationException>(() =>
            {
                IntResourceManager irm = new IntResourceManager(1);

                CommittableTransaction ct = new CommittableTransaction();
                /* Set ambient Tx */
                Transaction.Current = ct;

                /* Enlist */
                irm.Value = 2;

                IAsyncResult ar = ct.BeginCommit(null, null);
                IAsyncResult ar2 = ct.BeginCommit(null, null);
            });
        }
コード例 #4
0
ファイル: AsyncTest.cs プロジェクト: geoffkizer/corefx
        public void AsyncFail2()
        {
            Assert.Throws<TransactionAbortedException>(() =>
            {
                IntResourceManager irm = new IntResourceManager(1);

                CommittableTransaction ct = new CommittableTransaction();
                /* Set ambient Tx */
                Transaction.Current = ct;

                /* Enlist */
                irm.Value = 2;
                irm.FailPrepare = true;

                IAsyncResult ar = ct.BeginCommit(null, null);

                ct.EndCommit(ar);
            });
        }
コード例 #5
0
ファイル: TransactionScopeTest.cs プロジェクト: dotnet/corefx
        public void ExplicitTransaction10()
        {
            CommittableTransaction ct = new CommittableTransaction();

            IntResourceManager irm = new IntResourceManager(1);
            Transaction.Current = ct;
            try
            {
                irm.Value = 2;

                TransactionScope scope = new TransactionScope(ct);
                Assert.Equal(ct, Transaction.Current);
                Assert.Throws<TransactionAbortedException>(() => ct.Commit());
                irm.Check(0, 0, 1, 0, "irm");
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #6
0
        public static void TestCase_OutcomeRegistration(bool promote)
        {
            string testCaseDescription = string.Format(
                "TestCase_OutcomeRegistration promote={0}",
                promote
                );

            Trace("**** " + testCaseDescription + " ****");

            AutoResetEvent pspeCompleted = new AutoResetEvent(false);
            NonMSDTCPromoterEnlistment pspe = null;
            int numberOfCompletions = 0;
            CommittableTransaction tx = null;

            try
            {
                tx = new CommittableTransaction(TimeSpan.FromSeconds(5));

                tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                {
                    Trace("Completed event registered before PSPE");
                    numberOfCompletions++;
                    Assert.Equal(TransactionStatus.Committed, completedArgs.Transaction.TransactionInformation.Status);
                };

                pspe = (NonMSDTCPromoterEnlistment)CreatePSPEEnlistment(NonMsdtcPromoterTests.PromoterType1,
                    NonMsdtcPromoterTests.PromotedToken1,
                    pspeCompleted,
                    /*nonMSDTC = */ true,
                    tx,
                    /*spcResponse=*/ TransactionStatus.Committed,
                    /*expectRejection=*/ false
                    );

                tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                {
                    Trace("Completed event registered after PSPE");
                    numberOfCompletions++;
                    Assert.Equal(TransactionStatus.Committed, completedArgs.Transaction.TransactionInformation.Status);
                };

                if (promote)
                {
                    Promote(testCaseDescription, NonMsdtcPromoterTests.PromotedToken1, tx);

                    tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                    {
                        Trace("Completed event registered after promote");
                        numberOfCompletions++;
                        Assert.Equal(TransactionStatus.Committed, completedArgs.Transaction.TransactionInformation.Status);
                    };
                }

                tx.Commit();
            }
            catch (Exception ex)
            {
                Assert.Null(ex);
            }

            tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
            {
                Trace("Completed event registered after commit");
                numberOfCompletions++;
                Assert.Equal(TransactionStatus.Committed, completedArgs.Transaction.TransactionInformation.Status);
            };

            Assert.True(pspeCompleted.WaitOne(TimeSpan.FromSeconds(5)));

            if (promote)
            {
                Assert.True(pspe.Promoted);
            }
            else
            {
                Assert.False(pspe.Promoted);
            }

            Assert.Equal((promote ? 4 : 3), numberOfCompletions);

            TestPassed();
        }
コード例 #7
0
        public void ExplicitTransaction7()
        {
            Assert.Throws<TransactionException>(() =>
            {
                CommittableTransaction ct = new CommittableTransaction();

                IntResourceManager irm = new IntResourceManager(1);
                irm.Value = 2;
                ct.Commit();
                /* Cannot accept any new work now, so TransactionException */
                ct.Rollback();
            });
        }
コード例 #8
0
        public void ExplicitTransaction6()
        {
            Assert.Throws<InvalidOperationException>(() =>
            {
                CommittableTransaction ct = new CommittableTransaction();

                IntResourceManager irm = new IntResourceManager(1);
                irm.Value = 2;
                ct.Commit();

                ct.Commit();
            });
        }
コード例 #9
0
        public void ExplicitTransactionRollback()
        {
            Assert.Null(Transaction.Current);

            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;
            Transaction.Current = ct;
            try
            {
                IntResourceManager irm = new IntResourceManager(1);
                irm.Value = 2;
                Assert.Equal(TransactionStatus.Active, ct.TransactionInformation.Status);
                ct.Rollback();

                Assert.Equal(1, irm.Value);
                Assert.Equal(TransactionStatus.Aborted, ct.TransactionInformation.Status);
            }
            finally
            {
                Transaction.Current = oldTransaction;
            }
        }
コード例 #10
0
 public TxnBatch(IBTTransportProxy transportProxy, ControlledTermination control, IDtcTransaction comTxn, CommittableTransaction transaction, ManualResetEvent orderedEvent, bool makeSuccessCall) : base(transportProxy, makeSuccessCall)
 {
     this.control      = control;
     this.comTxn       = comTxn;
     this.transaction  = transaction;
     this.orderedEvent = orderedEvent;
 }
コード例 #11
0
 public PromotedTx(CommittableTransaction commitTx)
 {
     DtcTxCreator.Trace("PromotedTx constructor");
     _commitTx = commitTx;
 }
コード例 #12
0
 public DurableResourceManager(NpgsqlResourceManager rm, INpgsqlTransactionCallbacks callbacks,
                               CommittableTransaction tx)
 {
     _callbacks = callbacks;
 }
コード例 #13
0
        public TxnBatch(IBTTransportProxy transportProxy, ControlledTermination control, CommittableTransaction transaction, ManualResetEvent orderedEvent, bool makeSuccessCall) : base(transportProxy, makeSuccessCall)
        {
            this.control = control;

            this.comTxn = TransactionInterop.GetDtcTransaction(transaction);

            //  the System.Transactions transaction - must be the original transaction - only that can be used to commit
            this.transaction = transaction;

            this.orderedEvent = orderedEvent;
        }
コード例 #14
0
        public override void SendToEndpoint(global::Neuron.Esb.ESBMessage message, CommittableTransaction tx)
        {
            RaiseAdapterInfo(ErrorLevel.Info, string.Format("MESSAGE ID: {0} ~ TOPIC: {1}", message.Header.MessageId, message.Header.Topic));

            TweetStatus(message);
        }
コード例 #15
0
 /// <summary>
 /// The Reciever always needs a transaction to protect its conversation, but a Service may wish to enlist other work
 /// in the transaction.  TakeTransaction will detach the transaction that the conversation uses from the reciever and allow
 /// the server to enlist other work in it and control its fate.  
 /// </summary>
 /// <returns></returns>
 public CommittableTransaction TakeTransaction()
 {
     CommittableTransaction tran = this.tx;
     tx = null;
     return tran;
 }
コード例 #16
0
        internal void EmployWorker(WorkerCard workerCard, WorkAssignment workAssignment, CommittableTransaction committableTransaction)
        {
            WorkerRunner workerRunner = null;

            switch (workAssignment.WorkRequest.WorkerIsolationLevel)
            {
            case WorkerIsolationLevel.SeparateAppDomain:
                workerRunner = new WorkerRunnerAppDomain(workerCard, workAssignment, committableTransaction);
                break;

            case WorkerIsolationLevel.SeparateProcess:
                workerRunner = new WorkerRunnerProcess(workerCard, workAssignment, committableTransaction);

                // Debug
                //workerRunner = new WorkerRunnerThread(workerCard, WorkAssignment, committableTransaction);
                break;

            case WorkerIsolationLevel.SeparateThread:
            case WorkerIsolationLevel.Default:
            default:
                workerRunner = new WorkerRunnerThread(workerCard, workAssignment, committableTransaction);
                break;
            }

            try
            {
                AllWorkerRunners.Add(workAssignment.WorkerId, workerRunner);
            }
            catch (Exception ex)
            {
                Tracer.Error("AllWorkerRunners.Add({0}) caused exception: {1}", workAssignment.WorkerId, ex);
                foreach (string workerId in AllWorkerRunners.Keys)
                {
                    Tracer.Error("AllWorkerRunners contains worker {0}", workerId);
                }
                throw;
            }
            workerRunner.Run();
        }
コード例 #17
0
        public static void TestCase_TransactionTimeout(bool promote)
        {
            string testCaseDescription = string.Format(
                "TestCase_TransactionTimeout promote={0}",
                promote
                );

            Trace("**** " + testCaseDescription + " ****");

            AutoResetEvent pspeCompleted = new AutoResetEvent(false);
            NonMSDTCPromoterEnlistment pspe = null;

            try
            {
                CommittableTransaction tx = new CommittableTransaction(TimeSpan.FromSeconds(3));

                pspe = (NonMSDTCPromoterEnlistment)CreatePSPEEnlistment(NonMsdtcPromoterTests.PromoterType1,
                    NonMsdtcPromoterTests.PromotedToken1,
                    pspeCompleted,
                    /*nonMSDTC = */ true,
                    tx,
                    /*spcResponse=*/ TransactionStatus.Committed,
                    /*expectRejection=*/ false
                    );

                if (promote)
                {
                    Promote(testCaseDescription, NonMsdtcPromoterTests.PromotedToken1, tx);
                }

                NoStressTrace(string.Format("There will be a 7 second delay here - {0}", DateTime.Now.ToString()));

                Task.Delay(TimeSpan.FromSeconds(7)).Wait();

                NoStressTrace(string.Format("Woke up from sleep. Attempting Commit - {0}", DateTime.Now.ToString()));

                tx.Commit();
            }
            catch (Exception ex)
            {
                if (ex.GetType() != typeof(TransactionAbortedException))
                {
                    TestFailed(testCaseDescription, string.Format("Unexpected exception {0}: {1}", ex.GetType().ToString(), ex.ToString()));
                    return;
                }
            }

            if (pspeCompleted.WaitOne(TimeSpan.FromSeconds(5)))
            {
                if (!promote && pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment promoted");
                    return;
                }

                if (promote && !pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment was not promoted");
                    return;
                }

                if (!(pspe.Aborted))
                {
                    TestFailed(testCaseDescription, "The enlistment did not abort");
                    return;
                }

                TestPassed(true);
            }
            else
            {
                TestFailed(testCaseDescription, "Timeout waiting for enlistment outcomes");
            }
        }
コード例 #18
0
 public SingleMessageReceiveTxnBatch(IBTTransportProxy transportProxy, ControlledTermination control, CommittableTransaction transaction, ManualResetEvent orderedEvent) : base(transportProxy, control, transaction, orderedEvent, true)
 {
 }
コード例 #19
0
        public static void TestCase_OutcomeRegistration(bool promote)
        {
            string testCaseDescription = string.Format(
                "TestCase_OutcomeRegistration promote={0}",
                promote
                );

            Trace("**** " + testCaseDescription + " ****");

            AutoResetEvent pspeCompleted = new AutoResetEvent(false);
            NonMSDTCPromoterEnlistment pspe = null;
            int numberOfCompletions = 0;
            CommittableTransaction tx = null;

            try
            {
                tx = new CommittableTransaction(TimeSpan.FromSeconds(5));

                tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                {
                    Trace("Completed event registered before PSPE");
                    numberOfCompletions++;
                    if (completedArgs.Transaction.TransactionInformation.Status != TransactionStatus.Committed)
                    {
                        TestFailed(testCaseDescription, "Completed event registered before PSPE did not receive committed");
                        return;
                    }
                };

                pspe = (NonMSDTCPromoterEnlistment)CreatePSPEEnlistment(NonMsdtcPromoterTests.PromoterType1,
                    NonMsdtcPromoterTests.PromotedToken1,
                    pspeCompleted,
                    /*nonMSDTC = */ true,
                    tx,
                    /*spcResponse=*/ TransactionStatus.Committed,
                    /*expectRejection=*/ false
                    );

                tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                {
                    Trace("Completed event registered after PSPE");
                    numberOfCompletions++;
                    if (completedArgs.Transaction.TransactionInformation.Status != TransactionStatus.Committed)
                    {
                        TestFailed(testCaseDescription, "Completed event registered after PSPE did not receive committed");
                        return;
                    }
                };

                if (promote)
                {
                    Promote(testCaseDescription, NonMsdtcPromoterTests.PromotedToken1, tx);

                    tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
                    {
                        Trace("Completed event registered after promote");
                        numberOfCompletions++;
                        if (completedArgs.Transaction.TransactionInformation.Status != TransactionStatus.Committed)
                        {
                            TestFailed(testCaseDescription, "Completed event registered after promote did not receive committed");
                            return;
                        }
                    };
                }

                tx.Commit();
            }
            catch (Exception ex)
            {
                TestFailed(testCaseDescription, string.Format("Unexpected exception {0}: {1}", ex.GetType().ToString(), ex.ToString()));
                return;
            }

            tx.TransactionCompleted += delegate (object sender, TransactionEventArgs completedArgs)
            {
                Trace("Completed event registered after commit");
                numberOfCompletions++;
                if (completedArgs.Transaction.TransactionInformation.Status != TransactionStatus.Committed)
                {
                    TestFailed(testCaseDescription, "Completed event registered after commit did not receive committed");
                    return;
                }
            };

            if (pspeCompleted.WaitOne(TimeSpan.FromSeconds(5)))
            {
                if (!promote && pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment promoted");
                    return;
                }

                if (promote && !pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment was not promoted");
                    return;
                }

                if (numberOfCompletions != (promote ? 4 : 3))
                {
                    TestFailed(testCaseDescription, string.Format("Unexpected number of completion event firings - {0}", numberOfCompletions));
                    return;
                }
                TestPassed();
            }
            else
            {
                TestFailed(testCaseDescription, "Timeout waiting for enlistment outcomes");
            }
        }
コード例 #20
0
 public AbortOnFailureReceiveTxnBatch(IBTTransportProxy transportProxy, ControlledTermination control, IDtcTransaction comTxn, CommittableTransaction transaction, ManualResetEvent orderedEvent, TxnAborted txnAborted)
     : base(transportProxy, control, comTxn, transaction, orderedEvent, false)
 {
     this.txnAborted = txnAborted;
 }
コード例 #21
0
 public void Rollback()
 {
     DtcTxCreator.Trace("PromotedTx.Rollback");
     _commitTx.Rollback();
     _commitTx = null;
 }
コード例 #22
0
 public AbortOnAllFailureReceiveTxnBatch(IBTTransportProxy transportProxy, ControlledTermination control, CommittableTransaction transaction, ManualResetEvent orderedEvent, StopProcessing stopProcessing) : base(transportProxy, control, transaction, orderedEvent, false)
 {
     this.stopProcessing = stopProcessing;
 }
コード例 #23
0
        public virtual async Task SaveChanges_uses_enlisted_transaction(bool async, bool autoTransactionsEnabled)
        {
            using (var transaction = new CommittableTransaction(TimeSpan.FromMinutes(10)))
            {
                using (var context = CreateContext())
                {
                    context.Database.EnlistTransaction(transaction);
                    context.Database.AutoTransactionsEnabled = autoTransactionsEnabled;

                    context.Add(
                        new TransactionCustomer
                    {
                        Id   = 77,
                        Name = "Bobble"
                    });

                    context.Entry(context.Set <TransactionCustomer>().OrderBy(c => c.Id).Last()).State = EntityState.Added;

                    if (async)
                    {
                        await Assert.ThrowsAsync <DbUpdateException>(() => context.SaveChangesAsync());
                    }
                    else
                    {
                        Assert.Throws <DbUpdateException>(() => context.SaveChanges());
                    }

                    context.Database.AutoTransactionsEnabled = true;
                }

                if (AmbientTransactionsSupported)
                {
                    Assert.Equal(
                        RelationalResources.LogExplicitTransactionEnlisted(new TestLogger <TestRelationalLoggingDefinitions>()).GenerateMessage("Serializable"),
                        Fixture.ListLoggerFactory.Log.First().Message);
                }
                else
                {
                    Assert.Equal(
                        RelationalResources.LogAmbientTransaction(new TestLogger <TestRelationalLoggingDefinitions>()).GenerateMessage(),
                        Fixture.ListLoggerFactory.Log.First().Message);

                    if (!autoTransactionsEnabled)
                    {
                        using (var context = CreateContext())
                        {
                            context.Entry(context.Set <TransactionCustomer>().Single(c => c.Id == 77)).State = EntityState.Deleted;

                            if (async)
                            {
                                await context.SaveChangesAsync();
                            }
                            else
                            {
                                context.SaveChanges();
                            }
                        }
                    }
                }
            }

            AssertStoreInitialState();
        }
コード例 #24
0
        void ProcessOpen()
        {
            CommittableTransaction tx = new CommittableTransaction();

            txscope = new TransactionScope(tx);
        }
コード例 #25
0
        public void ExplicitTransaction3()
        {
            Assert.Null(Transaction.Current);
            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;

            Transaction.Current = ct;
            try
            {
                IntResourceManager irm = new IntResourceManager(1);

                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew))
                {
                    Assert.True(ct != Transaction.Current, "Scope with RequiresNew should have a new ambient transaction");

                    irm.Value = 3;
                    scope.Complete();
                }

                irm.Value = 2;

                Assert.Equal(3, irm.Actual);

                Assert.Equal(ct, Transaction.Current);
                ct.Commit();
                Assert.Equal(2, irm.Actual);
            }
            finally
            {
                Transaction.Current = oldTransaction;
            }
        }
コード例 #26
0
        public async Task <IActionResult> Create(OrderViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                using (var transaction = new CommittableTransaction(new TransactionOptions {
                    IsolationLevel = IsolationLevel.ReadCommitted
                }))
                {
                    var user = await _dataContext.Users.Where(u => u.UserName == User.Identity.Name).FirstOrDefaultAsync();

                    try
                    {
                        var order = new Order
                        {
                            Id          = viewModel.Id,
                            StartDate   = viewModel.StartDate.ToUniversalTime(),
                            EndDate     = viewModel.EndDate.ToUniversalTime(),
                            Payment     = viewModel.Payment,
                            Deposit     = viewModel.Deposit,
                            Remarks     = viewModel.Remarks,
                            Pending     = viewModel.Pending,
                            Customer    = await _dataContext.Customers.FindAsync(viewModel.CustomerId),
                            Warehouse   = await _dataContext.Warehouses.FindAsync(viewModel.WarehouseId),
                            House       = await _dataContext.Houses.FindAsync(viewModel.HouseId),
                            DayPayment  = await _dataContext.DayPayments.FindAsync(viewModel.DayPaymentId),
                            TypePayment = await _dataContext.TypePayments.FindAsync(viewModel.TypePaymentId),
                            Seller      = await _dataContext.Sellers.FindAsync(viewModel.SellerId),
                            Helper      = await _dataContext.Helpers.FindAsync(viewModel.HelperId),
                            Collector   = await _dataContext.Collectors.FindAsync(viewModel.CollectorId),
                            State       = await _dataContext.States.FindAsync(viewModel.StateId),
                        };

                        var details2 = _dataContext.OrderTmps.Where(pt => pt.Username == User.Identity.Name).ToList();
                        foreach (var detail2 in details2)
                        {
                            order = new Order
                            {
                                Id          = viewModel.Id,
                                StartDate   = viewModel.StartDate.ToUniversalTime(),
                                EndDate     = viewModel.EndDate.ToUniversalTime(),
                                Payment     = viewModel.Payment,
                                Deposit     = viewModel.Deposit,
                                Remarks     = viewModel.Remarks,
                                Pending     = viewModel.Pending,
                                Customer    = await _dataContext.Customers.FindAsync(detail2.Customer.Id),
                                Warehouse   = await _dataContext.Warehouses.FindAsync(viewModel.WarehouseId),
                                House       = await _dataContext.Houses.FindAsync(viewModel.HouseId),
                                DayPayment  = await _dataContext.DayPayments.FindAsync(viewModel.DayPaymentId),
                                TypePayment = await _dataContext.TypePayments.FindAsync(viewModel.TypePaymentId),
                                Seller      = await _dataContext.Sellers.FindAsync(viewModel.SellerId),
                                Helper      = await _dataContext.Helpers.FindAsync(viewModel.HelperId),
                                Collector   = await _dataContext.Collectors.FindAsync(detail2.Customer.Collector.Id),
                                State       = await _dataContext.States.FindAsync(viewModel.StateId),
                            };

                            _dataContext.Orders.Add(order);
                            _dataContext.OrderTmps.Remove(detail2);
                        }

                        _dataContext.Orders.Add(order);
                        await _dataContext.SaveChangesAsync();

                        var details = _dataContext.OrderDetailTmps.Include(odt => odt.Product).Where(odt => odt.Username == User.Identity.Name).ToList();

                        foreach (var detail in details)
                        {
                            var orderDetail = new OrderDetail
                            {
                                Name     = detail.Name,
                                Price    = detail.Price,
                                Quantity = detail.Quantity,
                                Order    = await _dataContext.Orders.FindAsync(order.Id),
                                Product  = await _dataContext.Products.FindAsync(detail.Product.Id),
                            };

                            _dataContext.OrderDetails.Add(orderDetail);
                            _dataContext.OrderDetailTmps.Remove(detail);
                        }
                        await _dataContext.SaveChangesAsync();

                        transaction.Commit();
                    }
                    catch (Exception)
                    {
                        transaction.Rollback();
                    }
                }

                return(RedirectToAction(nameof(Index)));
            }
            viewModel.Houses       = _combosHelper.GetComboHouses();
            viewModel.TypePayments = _combosHelper.GetComboTypePayments();
            viewModel.DayPayments  = _combosHelper.GetComboDayPayments();
            viewModel.Sellers      = _combosHelper.GetComboSellers();
            viewModel.Helpers      = _combosHelper.GetComboHelpers();
            viewModel.States       = _combosHelper.GetComboStates();
            viewModel.Warehouses   = _combosHelper.GetComboWarehouses();
            viewModel.Details      = _dataContext.OrderDetailTmps.Where(odt => odt.Username == User.Identity.Name).ToList();
            viewModel.Details2     = _dataContext.OrderTmps.Include(ot => ot.Customer).Where(ot => ot.Username == User.Identity.Name).ToList();
            return(View(viewModel));
        }
コード例 #27
0
        public void ExplicitTransaction6b()
        {
            CommittableTransaction ct = new CommittableTransaction();

            IntResourceManager irm = new IntResourceManager(1);

            Transaction.Current = ct;
            try
            {
                TransactionScope scope1 = new TransactionScope();
                /* Enlist */
                irm.Value = 2;

                scope1.Complete();

                Assert.Throws<TransactionAbortedException>(() => ct.Commit());
                irm.Check(0, 0, 1, 0, "irm");

                scope1.Dispose();
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #28
0
        public async Task CrossEntityTransactionSendsFirstRollback()
        {
            await using var client = CreateCrossEntityTxnClient();
            await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);

            await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);

            await using var queueC = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);

            await using var noTxClient = CreateClient();
            var senderA   = noTxClient.CreateSender(queueA.QueueName);
            var receiverA = client.CreateReceiver(queueA.QueueName);
            var receiverB = client.CreateReceiver(queueB.QueueName);
            var senderB   = client.CreateSender(queueB.QueueName);
            var senderC   = client.CreateSender(queueC.QueueName);
            var receiverC = noTxClient.CreateReceiver(queueC.QueueName);

            var message = new ServiceBusMessage();

            // B is the send via entity since it is first
            await senderB.SendMessageAsync(message);

            await senderA.SendMessageAsync(message);

            // you can't use a receiver after a sender (for a different entity) when using a Transaction Group because it would be
            // saying that you want to receive via the sender entity which isn't possible

            Assert.ThrowsAsync <InvalidOperationException>(async() => await receiverA.ReceiveMessageAsync());

            // After the above throws, the session gets closed by the AMQP lib, so we are testing whether the fault tolerant session/controller
            // objects get re-created correctly.

            ServiceBusReceivedMessage receivedMessageB = await receiverB.ReceiveMessageAsync();

            // If the transaction succeeds, then all the operations occurred on the same partition.
            var transaction = new CommittableTransaction();

            using (var ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
            {
                // this is allowed because it is on B
                await receiverB.CompleteMessageAsync(receivedMessageB);

                // send to C via B - this is allowed because we are sending
                await senderC.SendMessageAsync(message);

                ts.Complete();
            }
            transaction.Rollback();
            // Adding delay since transaction Commit/Rollback is an asynchronous operation.
            await Task.Delay(TimeSpan.FromSeconds(2));

            await receiverB.AbandonMessageAsync(receivedMessageB);

            receivedMessageB = await receiverB.ReceiveMessageAsync();

            Assert.IsNotNull(receivedMessageB);
            await receiverB.AbandonMessageAsync(receivedMessageB);

            var receivedMessageC = await receiverC.ReceiveMessageAsync();

            Assert.IsNull(receivedMessageC);

            // If the transaction succeeds, then all the operations occurred on the same partition.
            using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                receivedMessageB = await receiverB.ReceiveMessageAsync();

                // this is allowed because it is on B
                await receiverB.CompleteMessageAsync(receivedMessageB);

                // this will fail because it is not part of txn group
                Assert.ThrowsAsync <ServiceBusException>(async() => await senderA.SendMessageAsync(message));

                ts.Complete();
            }

            receivedMessageB = await receiverB.ReceiveMessageAsync();

            Assert.IsNull(receivedMessageB);
        }
コード例 #29
0
        public void ExplicitTransaction9()
        {
            Assert.Throws<InvalidOperationException>(() =>
            {
                CommittableTransaction ct = new CommittableTransaction();

                IntResourceManager irm = new IntResourceManager(1);
                ct.BeginCommit(null, null);
                ct.BeginCommit(null, null);
            });
        }
コード例 #30
0
ファイル: DBMSSQL.cs プロジェクト: liwenproject/WinFormLab
        /// <summary>DB批次作業
        /// </summary>
        public bool DBExec(string connstr, string SQL, List <List <SqlParameter> > dbParametersList, ref string errmsg)
        {
            bool          result = true;
            SqlCommand    dbCmd  = new SqlCommand();
            SqlConnection dbConn = new SqlConnection(connstr);

            dbConn.Open();
            CommittableTransaction cTra = new CommittableTransaction();

            dbConn.EnlistTransaction(cTra);
            dbCmd.Connection     = dbConn;
            dbCmd.CommandTimeout = 10;

            try
            {
                dbCmd.CommandType = CommandType.Text;
                dbCmd.CommandText = SQL;
                if (dbParametersList != null)
                {
                    errmsg = "";
                    foreach (List <SqlParameter> dbParameters in dbParametersList)
                    {
                        dbCmd.Parameters.Clear();
                        dbCmd.Parameters.AddRange(dbParameters.ToArray());

                        try
                        {
                            dbCmd.ExecuteNonQuery();
                        }
                        catch (Exception ex)
                        {
                            errmsg = ex.Message;
                            cTra.Rollback();
                            result = false;
                            break;
                        }
                    }
                }

                //全部成功才 commit
                if (errmsg.Trim().Length == 0)
                {
                    cTra.Commit();
                }
            }
            catch (TransactionException tex)
            {
                if (!cTra.TransactionInformation.Status.Equals(TransactionStatus.Aborted))
                {
                    errmsg = tex.Message;
                    cTra.Rollback(tex);
                    result = false;
                }
            }
            catch (Exception ex)
            {
                errmsg = ex.Message;
                cTra.Rollback();
                result = false;
            }
            finally
            {
                cTra.Dispose();
                dbCmd.Dispose();
                dbConn.Close();
                dbConn.Dispose();
            }

            return(result);
        }
コード例 #31
0
        public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameTransaction()
        {
            var queueName = TestConstants.PartitionedQueueName;
            var sender    = new MessageSender(ConnectionString, queueName);
            var receiver  = new MessageReceiver(ConnectionString, queueName);

            try
            {
                string body     = Guid.NewGuid().ToString("N");
                var    message1 = new Message((body + "1").GetBytes())
                {
                    PartitionKey = "1"
                };
                var message2 = new Message((body + "2").GetBytes())
                {
                    PartitionKey = "2"
                };

                // Two send operations to different partitions.
                var transaction = new CommittableTransaction();
                using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
                {
                    await sender.SendAsync(message1);

                    await Assert.ThrowsAsync <InvalidOperationException>(
                        async() => await sender.SendAsync(message2));

                    ts.Complete();
                }

                transaction.Rollback();

                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
                // Operating on the same message should not be done.
                await Task.Delay(TimeSpan.FromSeconds(2));

                // Two complete operations to different partitions.
                await sender.SendAsync(message1);

                await sender.SendAsync(message2);

                var receivedMessage1 = await receiver.ReceiveAsync(ReceiveTimeout);

                Assert.NotNull(receivedMessage1);
                var receivedMessage2 = await receiver.ReceiveAsync(ReceiveTimeout);

                Assert.NotNull(receivedMessage2);

                transaction = new CommittableTransaction();
                using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
                {
                    await receiver.CompleteAsync(receivedMessage1.SystemProperties.LockToken);

                    await Assert.ThrowsAsync <InvalidOperationException>(
                        async() => await receiver.CompleteAsync(receivedMessage2.SystemProperties.LockToken));

                    ts.Complete();
                }

                transaction.Rollback();

                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
                // Operating on the same message should not be done.
                await Task.Delay(TimeSpan.FromSeconds(2));

                await receiver.CompleteAsync(receivedMessage1.SystemProperties.LockToken);

                await receiver.CompleteAsync(receivedMessage2.SystemProperties.LockToken);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            finally
            {
                await sender.CloseAsync();

                await receiver.CloseAsync();
            }
        }
コード例 #32
0
 /// <summary>
 /// Initializes a new instance of the PSTransaction class.
 /// </summary>
 internal PSTransaction(RollbackSeverity rollbackPreference, TimeSpan timeout)
 {
     _transaction       = new CommittableTransaction(timeout);
     RollbackPreference = rollbackPreference;
     _subscriberCount   = 1;
 }
コード例 #33
0
        public static void TestCase_TransactionTimeout(bool promote)
        {
            string testCaseDescription = string.Format(
                "TestCase_TransactionTimeout promote={0}",
                promote
                );

            Trace("**** " + testCaseDescription + " ****");

            AutoResetEvent pspeCompleted = new AutoResetEvent(false);
            NonMSDTCPromoterEnlistment pspe = null;

            Assert.Throws<TransactionAbortedException>(() =>
            {
                CommittableTransaction tx = new CommittableTransaction(TimeSpan.FromSeconds(1));

                pspe = (NonMSDTCPromoterEnlistment)CreatePSPEEnlistment(NonMsdtcPromoterTests.PromoterType1,
                    NonMsdtcPromoterTests.PromotedToken1,
                    pspeCompleted,
                    /*nonMSDTC = */ true,
                    tx,
                    /*spcResponse=*/ TransactionStatus.Committed,
                    /*expectRejection=*/ false
                    );

                if (promote)
                {
                    Promote(testCaseDescription, NonMsdtcPromoterTests.PromotedToken1, tx);
                }

                NoStressTrace(string.Format("There will be a 3 second delay here - {0}", DateTime.Now.ToString()));

                Task.Delay(TimeSpan.FromSeconds(3)).Wait();

                NoStressTrace(string.Format("Woke up from sleep. Attempting Commit - {0}", DateTime.Now.ToString()));

                tx.Commit();
            });

            Assert.True(pspeCompleted.WaitOne(TimeSpan.FromSeconds(5)));

            if (promote)
            {
                Assert.True(pspe.Promoted);
            }
            else
            {
                Assert.False(pspe.Promoted);
            }

            Assert.True(pspe.Aborted);

            TestPassed(true);
        }
コード例 #34
0
 /// <summary>
 /// Initializes a new instance of the PSTransaction class using a CommittableTransaction.
 /// </summary>
 internal PSTransaction(CommittableTransaction transaction, RollbackSeverity severity)
 {
     _transaction       = transaction;
     RollbackPreference = severity;
     _subscriberCount   = 1;
 }
コード例 #35
0
        public static void TestCase_DisposeCommittableTransaction(bool promote)
        {
            string testCaseDescription = string.Format(
                "TestCase_DisposeCommittableTransaction promote={0}",
                promote
                );

            Trace("**** " + testCaseDescription + " ****");

            AutoResetEvent pspeCompleted = new AutoResetEvent(false);
            NonMSDTCPromoterEnlistment pspe = null;
            Transaction savedTransaction = null;

            try
            {
                CommittableTransaction tx = new CommittableTransaction(TimeSpan.FromMinutes(1));
                savedTransaction = tx.Clone();

                pspe = (NonMSDTCPromoterEnlistment)CreatePSPEEnlistment(NonMsdtcPromoterTests.PromoterType1,
                    NonMsdtcPromoterTests.PromotedToken1,
                    pspeCompleted,
                    /*nonMSDTC = */ true,
                    tx,
                    /*spcResponse=*/ TransactionStatus.Committed,
                    /*expectRejection=*/ false
                    );

                if (promote)
                {
                    Promote(testCaseDescription, NonMsdtcPromoterTests.PromotedToken1, tx);
                }

                tx.Dispose();

                tx.Commit();
            }
            catch (Exception ex)
            {
                if (ex.GetType() != typeof(ObjectDisposedException))
                {
                    TestFailed(testCaseDescription, string.Format("Unexpected exception {0}: {1}", ex.GetType().ToString(), ex.ToString()));
                    return;
                }
            }

            if (pspeCompleted.WaitOne(TimeSpan.FromSeconds(5)))
            {
                if (!promote && pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment promoted");
                    return;
                }

                if (promote && !pspe.Promoted)
                {
                    TestFailed(testCaseDescription, "The enlistment was not promoted");
                    return;
                }

                if (!(pspe.Aborted))
                {
                    TestFailed(testCaseDescription, "The enlistment did not abort");
                    return;
                }

                if (savedTransaction.TransactionInformation.Status != TransactionStatus.Aborted)
                {
                    TestFailed(testCaseDescription, "The transaction did not abort");
                    return;
                }

                TestPassed();
            }
            else
            {
                TestFailed(testCaseDescription, "Timeout waiting for enlistment outcomes");
            }
        }
コード例 #36
0
        public async Task <BE_ResultadoTransaccion> Create(BE_TxExamenFisicoPollito value)
        {
            BE_ResultadoTransaccion vResultadoTransaccion = new BE_ResultadoTransaccion();

            _metodoName = regex.Match(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name).Groups[1].Value.ToString();

            vResultadoTransaccion.ResultadoMetodo     = _metodoName;
            vResultadoTransaccion.ResultadoAplicacion = _aplicacionName;

            try
            {
                using (SqlConnection conn = new SqlConnection(context.DevuelveConnectionSQL()))
                {
                    using (CommittableTransaction transaction = new CommittableTransaction())
                    {
                        await conn.OpenAsync();

                        conn.EnlistTransaction(transaction);

                        try
                        {
                            using (SqlCommand cmd = new SqlCommand(SP_INSERT, conn))
                            {
                                cmd.CommandType = System.Data.CommandType.StoredProcedure;

                                SqlParameter oParam = new SqlParameter("@IdExamenFisico", value.IdExamenFisico);
                                oParam.SqlDbType = SqlDbType.Int;
                                oParam.Direction = ParameterDirection.Output;
                                cmd.Parameters.Add(oParam);

                                cmd.Parameters.Add(new SqlParameter("@CodigoEmpresa", value.CodigoEmpresa));
                                cmd.Parameters.Add(new SqlParameter("@CodigoPlanta", value.CodigoPlanta));
                                cmd.Parameters.Add(new SqlParameter("@FecRegistro", value.FecRegistro));
                                cmd.Parameters.Add(new SqlParameter("@ResponsableInvetsa", value.ResponsableInvetsa));
                                cmd.Parameters.Add(new SqlParameter("@ResponsablePlanta", value.ResponsablePlanta));
                                cmd.Parameters.Add(new SqlParameter("@NumeroNacedora", value.NumeroNacedora));
                                cmd.Parameters.Add(new SqlParameter("@Lote", value.Lote));
                                cmd.Parameters.Add(new SqlParameter("@PesoPromedio", value.PesoPromedio));
                                cmd.Parameters.Add(new SqlParameter("@EdadReproductora", value.EdadReproductora));
                                cmd.Parameters.Add(new SqlParameter("@Sexo", value.Sexo));
                                cmd.Parameters.Add(new SqlParameter("@LineaGenetica", value.LineaGenetica));
                                cmd.Parameters.Add(new SqlParameter("@Calificacion", value.Calificacion));
                                cmd.Parameters.Add(new SqlParameter("@Uniformidad", value.Uniformidad));
                                cmd.Parameters.Add(new SqlParameter("@IdCalidad", value.IdCalidad));
                                cmd.Parameters.Add(new SqlParameter("@FirmaInvetsa", value.FirmaInvetsa));
                                cmd.Parameters.Add(new SqlParameter("@FirmaPlanta", value.FirmaPlanta));
                                cmd.Parameters.Add(new SqlParameter("@EmailFrom", value.EmailFrom));
                                cmd.Parameters.Add(new SqlParameter("@EmailTo", value.EmailTo));
                                cmd.Parameters.Add(new SqlParameter("@FlgCerrado", value.FlgCerrado));
                                cmd.Parameters.Add(new SqlParameter("@IdUsuarioCierre", value.IdUsuarioCierre));
                                cmd.Parameters.Add(new SqlParameter("@FecCierre", value.FecCierre));
                                cmd.Parameters.Add(new SqlParameter("@RegUsuario", value.RegUsuario));
                                cmd.Parameters.Add(new SqlParameter("@RegEstacion", value.RegEstacion));

                                await cmd.ExecuteNonQueryAsync();

                                value.IdExamenFisico = (int)cmd.Parameters["@IdExamenFisico"].Value;
                            }

                            using (SqlCommand cmd = new SqlCommand(SP_MERGE_DETALLE, conn))
                            {
                                foreach (BE_TxExamenFisicoPollitoDetalleNew item in value.ListDetalleNew)
                                {
                                    cmd.Parameters.Clear();
                                    cmd.CommandType = System.Data.CommandType.StoredProcedure;

                                    cmd.Parameters.Add(new SqlParameter("@IdExamenFisicoDetalle", item.IdExamenFisicoDetalle));
                                    cmd.Parameters.Add(new SqlParameter("@IdExamenFisico", value.IdExamenFisico));
                                    cmd.Parameters.Add(new SqlParameter("@NumeroPollito", item.NumeroPollito));
                                    if (item.Factor == 0)
                                    {
                                        cmd.Parameters.Add(new SqlParameter("@IdProcesoDetalle", item.IdProcesoDetalle));
                                    }
                                    else
                                    {
                                        cmd.Parameters.Add(new SqlParameter("@IdProcesoDetalle", item.Valor));
                                    }
                                    cmd.Parameters.Add(new SqlParameter("@Valor", item.Valor));
                                    cmd.Parameters.Add(new SqlParameter("@RegUsuario", value.RegUsuario));
                                    cmd.Parameters.Add(new SqlParameter("@RegEstacion", value.RegEstacion));

                                    await cmd.ExecuteNonQueryAsync();
                                }
                            }

                            using (SqlCommand cmd = new SqlCommand(SP_MERGE_DETALLE_RESUMEN, conn))
                            {
                                foreach (BE_TxExamenFisicoPollitoResumen item in value.ListDetalleResumen)
                                {
                                    cmd.Parameters.Clear();
                                    cmd.CommandType = System.Data.CommandType.StoredProcedure;

                                    cmd.Parameters.Add(new SqlParameter("@IdExamenFisicoDetalle", item.IdExamenFisicoDetalle));
                                    cmd.Parameters.Add(new SqlParameter("@IdExamenFisico", value.IdExamenFisico));
                                    cmd.Parameters.Add(new SqlParameter("@IdProceso", item.IdProceso));
                                    cmd.Parameters.Add(new SqlParameter("@Esperado", item.Esperado));
                                    cmd.Parameters.Add(new SqlParameter("@Obtenido", item.Obtenido));
                                    cmd.Parameters.Add(new SqlParameter("@RegUsuario", value.RegUsuario));
                                    cmd.Parameters.Add(new SqlParameter("@RegEstacion", value.RegEstacion));

                                    await cmd.ExecuteNonQueryAsync();
                                }
                            }

                            if (value.ListDetalleFotos != null)
                            {
                                if (value.ListDetalleFotos.Count() > 0)
                                {
                                    using (SqlCommand cmd = new SqlCommand(SP_MERGE_DETALLE_FOTO, conn))
                                    {
                                        foreach (BE_TxExamenFisicoPollitoDetalleFotos item in value.ListDetalleFotos)
                                        {
                                            cmd.Parameters.Clear();
                                            cmd.CommandType = System.Data.CommandType.StoredProcedure;

                                            cmd.Parameters.Add(new SqlParameter("@IdExamenFisicoDetalle", item.IdExamenFisicoDetalle));
                                            cmd.Parameters.Add(new SqlParameter("@IdExamenFisico", value.IdExamenFisico));
                                            cmd.Parameters.Add(new SqlParameter("@Foto", item.Foto));
                                            cmd.Parameters.Add(new SqlParameter("@RegUsuario", value.RegUsuario));
                                            cmd.Parameters.Add(new SqlParameter("@RegEstacion", value.RegEstacion));

                                            await cmd.ExecuteNonQueryAsync();
                                        }
                                    }
                                }
                            }

                            transaction.Commit();

                            vResultadoTransaccion.IdRegistro           = (int)value.IdExamenFisico;
                            vResultadoTransaccion.ResultadoCodigo      = 0;
                            vResultadoTransaccion.ResultadoDescripcion = "Se realizo correctamente";
                        }
                        catch (Exception ex)
                        {
                            transaction.Rollback();
                            vResultadoTransaccion.ResultadoCodigo      = -1;
                            vResultadoTransaccion.ResultadoDescripcion = ex.Message.ToString();
                            return(vResultadoTransaccion);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                vResultadoTransaccion.ResultadoCodigo      = -1;
                vResultadoTransaccion.ResultadoDescripcion = ex.Message.ToString();
                return(vResultadoTransaccion);
            }

            return(vResultadoTransaccion);
        }
コード例 #37
0
 public byte[] CreatePromotedTx(ref PromotedTx promotedTx)
 {
     DtcTxCreator.Trace("DtcTxCreator.CreatePromotedTx");
     byte[] propagationToken;
     CommittableTransaction commitTx = new CommittableTransaction();
     promotedTx = new PromotedTx(commitTx);
     propagationToken = TransactionInterop.GetTransmitterPropagationToken(commitTx);
     return propagationToken;
 }
コード例 #38
0
        protected internal override void CommitWorkBatch(WorkflowCommitWorkBatchService.CommitWorkBatchCallback commitWorkBatchCallback)
        {
            ManualResetEvent event2;
            DbRetry          retry      = new DbRetry(this._enableRetries);
            short            maxRetries = retry.MaxRetries;

Label_0013:
            event2 = new ManualResetEvent(false);
            Transaction          transaction    = null;
            SharedConnectionInfo connectionInfo = null;

            try
            {
                if (null == Transaction.Current)
                {
                    maxRetries     = 0;
                    transaction    = new CommittableTransaction();
                    connectionInfo = new SharedConnectionInfo(this.dbResourceAllocator, transaction, false, event2);
                }
                else
                {
                    transaction    = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
                    connectionInfo = new SharedConnectionInfo(this.dbResourceAllocator, transaction, true, event2);
                }
                this.AddToConnectionInfoTable(transaction, connectionInfo);
                using (TransactionScope scope = new TransactionScope(transaction))
                {
                    try
                    {
                        commitWorkBatchCallback();
                        scope.Complete();
                    }
                    finally
                    {
                        this.RemoveConnectionFromInfoTable(transaction);
                        event2.Set();
                    }
                }
                CommittableTransaction transaction2 = transaction as CommittableTransaction;
                if (transaction2 != null)
                {
                    transaction2.Commit();
                }
                DependentTransaction transaction3 = transaction as DependentTransaction;
                if (transaction3 != null)
                {
                    transaction3.Complete();
                }
            }
            catch (Exception exception)
            {
                transaction.Rollback();
                WorkflowTrace.Host.TraceEvent(TraceEventType.Error, 0, "SharedConnectionWorkflowCommitWorkBatchService caught exception from commitWorkBatchCallback: " + exception.ToString());
                if (!retry.TryDoRetry(ref maxRetries))
                {
                    throw;
                }
                WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "SharedConnectionWorkflowCommitWorkBatchService retrying commitWorkBatchCallback (retry attempt " + maxRetries.ToString(CultureInfo.InvariantCulture) + ")");
                goto Label_0013;
            }
            finally
            {
                event2.Close();
                if (transaction != null)
                {
                    transaction.Dispose();
                }
            }
        }
コード例 #39
0
 public void Commit()
 {
     DtcTxCreator.Trace("PromotedTx.Commit");
     _commitTx.Commit();
     _commitTx = null;
 }
コード例 #40
0
        public void ExplicitTransaction14()
        {
            CommittableTransaction ct = new CommittableTransaction();
            IntResourceManager irm = new IntResourceManager(1);

            Assert.Null(Transaction.Current);
            Transaction.Current = ct;
            try
            {
                irm.Value = 2;

                ct.Commit();

                Assert.Equal(TransactionStatus.Committed, ct.TransactionInformation.Status);
                Assert.Throws<InvalidOperationException>(() => ct.BeginCommit(null, null));
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #41
0
 public SystemTransactionContext(TransactionOptions options)
 {
     _transaction = new CommittableTransaction(options);
 }
コード例 #42
0
        public void ExplicitTransaction16()
        {
            CommittableTransaction ct = new CommittableTransaction();
            IntResourceManager irm0 = new IntResourceManager(3);
            IntResourceManager irm = new IntResourceManager(1);

            Assert.Null(Transaction.Current);

            Transaction.Current = ct;
            try
            {
                irm.FailPrepare = true;
                irm.FailWithException = true;
                irm.Value = 2;
                irm0.Value = 6;

                var e = Assert.Throws<TransactionAbortedException>(() => ct.Commit());
                Assert.NotNull(e.InnerException);
                Assert.IsType<NotSupportedException>(e.InnerException);
                irm.Check(1, 0, 0, 0, "irm");
                irm0.Check(0, 0, 1, 0, "irm0");
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #43
0
ファイル: TestPage.aspx.cs プロジェクト: PredictGroup/SAALUT
        protected void btnInitAkcionnieCeny_Click(object sender, EventArgs e)
        {
            string ret = "";


            SaalutDataClasses1DataContext context = new SaalutDataClasses1DataContext();

            //-------------------------------

            var delStoreInfo = (from d in context.StoreInfos
                                select d).FirstOrDefault();

            string jurCo = delStoreInfo.Company;
            string jurF  = delStoreInfo.AddressFact;

            context.StoreInfos.DeleteOnSubmit(delStoreInfo);
            context.SubmitChanges();

            UKMDataBaseConnects utl = new UKMDataBaseConnects();

            utl.InitialStoreInfoIns();

            var newStoreInfo = (from d in context.StoreInfos
                                select d).FirstOrDefault();

            newStoreInfo.Company     = jurCo;
            newStoreInfo.AddressFact = jurF;
            context.SubmitChanges();
            //---------------------------------

            var pricesAkcion = (from p in context.PricesAkcionnies
                                select p).FirstOrDefault();

            if (pricesAkcion != null)
            {
                return;
            }

            var store = (from s in context.StoreInfos
                         where s.Active == true
                         select s).FirstOrDefault();

            CommittableTransaction tx = new CommittableTransaction();

            // Create a connection object and data adapter
            MySqlConnection cnx = null;

            try
            {
                cnx = new MySqlConnection(connStr);

                MySqlDataAdapter adapter = new MySqlDataAdapter();

                // = делаем текущий прайс лист магазина


                // Выбираем магазин
                string       cmdText = "SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED ; select item, price, version, deleted from ukmserver.trm_in_pricelist_items where pricelist_id = '" + store.ActPriceList_ID_UKM.ToString() + "'  and deleted = 0; SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ ; ";
                MySqlCommand cmd     = new MySqlCommand(cmdText, cnx);
                cmd.CommandTimeout = 30000;

                // Create a fill a Dataset
                DataSet ds = new DataSet();
                adapter.SelectCommand = cmd;
                adapter.Fill(ds);

                DataTable pricesAkcionnie = ds.Tables[0];
                if (pricesAkcionnie != null)
                {
                    foreach (DataRow row1 in pricesAkcionnie.Rows)
                    {
                        string  artikulA       = (string)row1[0];
                        decimal priceA         = (decimal)row1[1];
                        int     version_priceA = (int)row1[2];
                        bool    delete_priceA  = (bool)row1[3];


                        double newPriceA = Double.Parse(priceA.ToString());

                        var good = (from g in context.Goods
                                    where g.Articul == artikulA
                                    select g).FirstOrDefault();

                        if (good == null)
                        {
                            continue;
                        }

                        //+
                        PricesAkcionnie npr1 = new PricesAkcionnie();
                        npr1.GoodID      = good.ID;
                        npr1.Price       = newPriceA;
                        npr1.Version_UKM = version_priceA;
                        npr1.TimeStamp   = DateTime.Now;
                        npr1.Active      = true;
                        context.PricesAkcionnies.InsertOnSubmit(npr1);
                        context.SubmitChanges();
                        //-
                    }
                }

                tx.Commit();
            }
            catch (MySqlException ex)
            {
                ret += "Error: " + ex.ToString();
                tx.Rollback();
            }
            finally
            {
                if (cnx != null)
                {
                    cnx.Close();
                }
            }

            return;
        }
コード例 #44
0
        public async Task <bool> Execute(UpdateResourcePermissionsParameter updateResourcePermissionsParameter)
        {
            if (updateResourcePermissionsParameter == null)
            {
                throw new ArgumentNullException(nameof(updateResourcePermissionsParameter));
            }

            if (string.IsNullOrWhiteSpace(updateResourcePermissionsParameter.ResourceId))
            {
                throw new BaseUmaException(Errors.ErrorCodes.InvalidRequestCode, Errors.ErrorDescriptions.TheResourceIdMustBeSpecified);
            }

            var resource = await _resourceSetRepository.Get(updateResourcePermissionsParameter.ResourceId).ConfigureAwait(false);

            if (resource == null)
            {
                throw new UmaResourceNotFoundException();
            }

            if (updateResourcePermissionsParameter.Subject != resource.Owner)
            {
                throw new UmaNotAuthorizedException();
            }

            var policiesToBeUpdated = resource.AuthPolicies.ToList();
            var policiesToBeRemoved = new List <string>();
            var length = policiesToBeUpdated.Count();

            for (int i = length - 1; i >= 0; i--)
            {
                var policy          = policiesToBeUpdated.ElementAt(i);
                var policyParameter = updateResourcePermissionsParameter.PolicyIds.FirstOrDefault(p => p == policy.Id);
                if (policyParameter == null)
                {
                    policiesToBeUpdated.Remove(policy);
                    policiesToBeRemoved.Add(policy.Id);
                }
            }

            using (var transaction = new CommittableTransaction(new TransactionOptions {
                IsolationLevel = IsolationLevel.ReadCommitted
            }))
            {
                try
                {
                    var operations = new List <Task <bool> >();
                    foreach (var policyId in policiesToBeRemoved)
                    {
                        operations.Add(_policyRepository.Delete(policyId));
                    }

                    await Task.WhenAll(operations).ConfigureAwait(false);

                    transaction.Commit();
                    return(true);
                }
                catch
                {
                    transaction.Rollback();
                    throw;
                }
            }
        }
コード例 #45
0
        public void ExplicitTransaction15()
        {
            CommittableTransaction ct = new CommittableTransaction();
            IntResourceManager irm = new IntResourceManager(1);
            IntResourceManager irm2 = new IntResourceManager(3);

            Assert.Null(Transaction.Current);
            Transaction.Current = ct;
            try
            {
                Assert.Throws<InvalidOperationException>(() =>
                {
                    using (TransactionScope scope = new TransactionScope())
                    {
                        irm.Value = 2;
                        Transaction.Current = new CommittableTransaction();
                        irm2.Value = 6;
                    }
                });
                irm.Check(0, 0, 1, 0, "irm");
                irm2.Check(0, 0, 1, 0, "irm2");
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #46
0
        // TODO: Issue #10353 - These variations need to be added once we have promotion support.

        /*
         * [InlineData(CloneType.Normal, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.RepeatableRead, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.ReadCommitted, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.ReadUncommitted, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Snapshot, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Chaos, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Unspecified, false, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
         */
        public void Run(CloneType cloneType, IsolationLevel isoLevel, bool forcePromote, bool completeClone, TransactionStatus expectedStatus)
        {
            TransactionOptions options = new TransactionOptions
            {
                IsolationLevel = isoLevel,
                // Shorten the delay before a timeout for blocking clones.
                Timeout = TimeSpan.FromSeconds(1)
            };

            CommittableTransaction tx = new CommittableTransaction(options);

            Transaction clone;

            switch (cloneType)
            {
            case CloneType.Normal:
            {
                clone = tx.Clone();
                break;
            }

            case CloneType.BlockingDependent:
            {
                clone = tx.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
                break;
            }

            case CloneType.RollbackDependent:
            {
                clone = tx.DependentClone(DependentCloneOption.RollbackIfNotComplete);
                break;
            }

            default:
            {
                throw new Exception("Unexpected CloneType - " + cloneType.ToString());
            }
            }

            if (forcePromote)
            {
                HelperFunctions.PromoteTx(tx);
            }

            Assert.Equal(clone.IsolationLevel, tx.IsolationLevel);
            Assert.Equal(clone.TransactionInformation.Status, tx.TransactionInformation.Status);
            Assert.Equal(clone.TransactionInformation.LocalIdentifier, tx.TransactionInformation.LocalIdentifier);
            Assert.Equal(clone.TransactionInformation.DistributedIdentifier, tx.TransactionInformation.DistributedIdentifier);

            CommittableTransaction cloneCommittable = clone as CommittableTransaction;

            Assert.Null(cloneCommittable);

            try
            {
                tx.Commit();
            }
            catch (TransactionAbortedException)
            {
                Assert.Equal(expectedStatus, TransactionStatus.Aborted);
            }

            Assert.Equal(expectedStatus, tx.TransactionInformation.Status);
        }
コード例 #47
0
        public void ExplicitTransactionCommit()
        {
            Assert.Null(Transaction.Current);

            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;
            Transaction.Current = ct;

            IntResourceManager irm = new IntResourceManager(1);
            irm.Value = 2;
            ct.Commit();

            Assert.Equal(2, irm.Value);
            Assert.Equal(TransactionStatus.Committed, ct.TransactionInformation.Status);
            Transaction.Current = oldTransaction;
        }
コード例 #48
0
        public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameTransaction()
        {
            await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false))
            {
                var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
                ServiceBusSender   sender   = client.CreateSender(scope.QueueName);
                ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);

                string            body     = Guid.NewGuid().ToString("N");
                ServiceBusMessage message1 = GetMessage(partitionKey: "1");
                ServiceBusMessage message2 = GetMessage(partitionKey: "2");

                // Two send operations to different partitions.
                var transaction = new CommittableTransaction();
                using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
                {
                    await sender.SendMessageAsync(message1);

                    Assert.ThrowsAsync <InvalidOperationException>(
                        async() => await sender.SendMessageAsync(message2));
                    ts.Complete();
                }

                transaction.Rollback();

                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
                // Operating on the same message should not be done.
                await Task.Delay(TimeSpan.FromSeconds(2));

                // Two complete operations to different partitions.
                await sender.SendMessageAsync(message1);

                await sender.SendMessageAsync(message2);

                ServiceBusReceivedMessage receivedMessage1 = await receiver.ReceiveMessageAsync();

                Assert.NotNull(receivedMessage1);
                ServiceBusReceivedMessage receivedMessage2 = await receiver.ReceiveMessageAsync();

                Assert.NotNull(receivedMessage2);

                transaction = new CommittableTransaction();
                using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
                {
                    await receiver.CompleteMessageAsync(receivedMessage1);

                    Assert.ThrowsAsync <InvalidOperationException>(
                        async() => await receiver.CompleteMessageAsync(receivedMessage2));
                    ts.Complete();
                }

                transaction.Rollback();

                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
                // Operating on the same message should not be done.
                await Task.Delay(TimeSpan.FromSeconds(2));

                await receiver.CompleteMessageAsync(receivedMessage1);

                // the service seems to abandon the message that
                // triggered the InvalidOperationException
                // in the transaction
                Assert.That(
                    async() =>
                    await receiver.CompleteMessageAsync(receivedMessage2), Throws.InstanceOf <ServiceBusException>()
                    .And.Property(nameof(ServiceBusException.Reason))
                    .EqualTo(ServiceBusException.FailureReason.MessageLockLost));
            }
        }
コード例 #49
0
        public void ExplicitTransaction2()
        {
            Assert.Null(Transaction.Current);
            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;

            Transaction.Current = ct;
            try
            {
                IntResourceManager irm = new IntResourceManager(1);

                irm.Value = 2;
                using (TransactionScope scope = new TransactionScope())
                {
                    Assert.Equal(ct, Transaction.Current);

                    /* Not calling scope.Complete
                    scope.Complete ();*/
                }

                Assert.Equal(TransactionStatus.Aborted, ct.TransactionInformation.Status);
                Assert.Equal(ct, Transaction.Current);
                Assert.Equal(1, irm.Actual);
                Assert.Equal(1, irm.NumRollback);
                irm.Check(0, 0, 1, 0, "irm");
            }
            finally
            {
                Transaction.Current = oldTransaction;
            }
            Assert.Throws<TransactionAbortedException>(() => ct.Commit());
        }
コード例 #50
0
        public static void ListenerThreadProc(object queueListenerConfig)
        {
            QueueListenerConfig config = (QueueListenerConfig)queueListenerConfig;

            while (!stopping)
            {
                TransactionOptions to = new TransactionOptions();
                to.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
                to.Timeout        = TimeSpan.MaxValue;

                CommittableTransaction tran = new CommittableTransaction(to);

                try
                {
                    using (var con = new SqlConnection(config.ConnectionString))
                    {
                        con.Open();
                        con.EnlistTransaction(tran);
                        byte[] message = ServiceBrokerUtils.GetMessage(config.QueueName, con, TimeSpan.FromSeconds(10));
                        if (message == null) //no message available
                        {
                            tran.Commit();
                            con.Close();
                            continue;
                        }

                        try
                        {
                            if (config.EnlistMessageProcessor)
                            {
                                using (var ts = new TransactionScope(tran))
                                {
                                    config.MessageProcessor(message);
                                    ts.Complete();
                                }
                            }
                            else
                            {
                                config.MessageProcessor(message);
                            }
                        }
                        catch (SqlException ex) //catch selected exceptions thrown by the MessageProcessor
                        {
                            config.FailedMessageProcessor(message, con, ex);
                        }

                        tran.Commit(); // the message processing succeeded or the FailedMessageProcessor ran so commit the RECEIVE
                        con.Close();
                    }
                }
                catch (SqlException ex)
                {
                    System.Diagnostics.Trace.Write("Error processing message from " + config.QueueName + ": " + ex.Message);
                    tran.Rollback();
                    tran.Dispose();
                    Thread.Sleep(1000);
                }
                ///catch any other non-fatal exceptions that should not stop the listener loop.
                catch (Exception ex)
                {
                    Trace.WriteLine("Unexpected Exception in Thread Proc for " + config.QueueName + ".  Thread Proc is exiting: " + ex.Message);
                    tran.Rollback();
                    tran.Dispose();
                    return;
                }
            }
        }
コード例 #51
0
        public void ExplicitTransaction5()
        {
            Assert.Null(Transaction.Current);
            CommittableTransaction ct = new CommittableTransaction();
            Transaction oldTransaction = Transaction.Current;

            /* Not setting ambient transaction 
			 Transaction.Current = ct; 
			 */

            IntResourceManager irm = new IntResourceManager(1);

            using (TransactionScope scope = new TransactionScope(ct))
            {
                Assert.Equal(ct, Transaction.Current);

                irm.Value = 2;

                /* Not completing this scope
				scope.Complete (); */
            }

            Assert.Equal(oldTransaction, Transaction.Current);
            Assert.Equal(TransactionStatus.Aborted, ct.TransactionInformation.Status);
            Assert.Equal(1, irm.Actual);

            irm.Check(0, 0, 1, 0, "irm");
        }
コード例 #52
0
        //-----------------------------------
        //Genera Cargo Solicitud Colegiado
        //-----------------------------------
        public bool Ins_GenerarCargoSolicitud(string CodEmpresa, long TipoPrograma, long TipoSolicitud, string cPerCodigo, int nPeriodo, DateTime dFechaSys, string NroSolicitud)
        {
            bool exito = false;

            string NroRecibo = "";
            long   nLinea    = 0;
            //double nImporte = 0;

            //para Tipo de cambio
            double     nTC  = 0;
            BL_Sistema daTC = new BL_Sistema();

            //para CtaCteItem
            BL_CtaCteItem            blCCItem      = new BL_CtaCteItem();
            BL_CtaCteIteLine         blCCItemLine  = new BL_CtaCteIteLine();
            BL_CtaCteIteLinRetencion blCCRetencion = new BL_CtaCteIteLinRetencion();
            BL_ImpuestoServicio      blImpServ     = new BL_ImpuestoServicio();

            //para Obtener Serv. Configurado
            BE_ReqCtaCteSysConfigParamterServicio ReqServConfig = new BE_ReqCtaCteSysConfigParamterServicio();
            BL_CtaCteSysConfigParamterServicio    daServConfig  = new BL_CtaCteSysConfigParamterServicio();

            //actuliza solicitud con el recibo de cargo
            BL_Solicitud DaSolAdm = new BL_Solicitud();

            //----------------------
            //CommittableTransaction
            //----------------------
            Transaction            oldAmbient = Transaction.Current;
            CommittableTransaction committableTransaction;

            committableTransaction = oldAmbient as CommittableTransaction;

            if (committableTransaction == null)
            {
                committableTransaction = new CommittableTransaction();
                Transaction.Current    = committableTransaction;
            }

            try
            {
                //using (TransactionScope tx = new TransactionScope(TransactionScopeOption.Required))
                //{
                //
                ReqServConfig.cPerJurCodigo         = CodEmpresa;
                ReqServConfig.nSisModulo            = 7001;          //default aun falta definir interface
                ReqServConfig.nParCodigo_nProCodigo = TipoSolicitud; //CLng(CboPrograma.SelectedValue)
                ReqServConfig.cFLag = "FEC";

                if (daServConfig.Get_SysConfParametrosServ(ReqServConfig).Rows.Count > 0)
                {
                    DataRow row = daServConfig.Get_SysConfParametrosServ(ReqServConfig).Rows[0];
                    //--------------
                    //Tipo de cambio
                    //--------------
                    if (Convert.ToInt32(row["nMonCodigo"]) == 2) //Dolar
                    {
                        if (daTC.Get_TipodeCambio(Convert.ToInt32(row["nMonCodigo"]), "TCD", String.Format("{0:dd/MM/yyyy}", dFechaSys), 0, 0).Rows.Count > 0)
                        {
                            //DataRow row = daTC.Get_TipodeCambio(ReqTC).Rows[0];
                            nTC = Convert.ToDouble(daTC.Get_TipodeCambio(Convert.ToInt32(row["nMonCodigo"]), "TCD", String.Format("{0:dd/MM/yyyy}", dFechaSys), 0, 0).Rows[0]["nCompra"]);
                        }
                        else
                        {
                            throw new ApplicationException("No se ha registrado el Tipo de Cambio del dia: " + String.Format("{0:ddd, MMM d, yyyy}", dFechaSys));
                        }
                    }
                    else
                    {
                        nTC = 1.0;
                    }

                    //----------
                    //CtaCteItem
                    //----------
                    //se comente esto porque la Actualizacion 28/01/2014 no se necesita esta variable
                    //foreach (DataRow fila in daServConfig.Get_SysConfParametrosServ(ReqServConfig).Rows)
                    //{
                    //    //Obteniendo el total del importe de recibo (cabezera)
                    //    nImporte = nImporte + Convert.ToDouble(fila["nSysValor"]);
                    //}

                    //Actualizacion 28/01/2014:
                    //porque necesitan que cada concepto salga en diferente recibo
                    //NroRecibo = blCCItem.Ins_CtaCteItem(CodEmpresa, cPerCodigo, nPeriodo, row["nCtaCteTipoCta"].ToString(), dFechaSys.Year, nImporte, dFechaSys, 1);

                    //--------------
                    //CtaCteIteLine
                    //--------------
                    //Recorro SysConfParametrosServ
                    foreach (DataRow fila in daServConfig.Get_SysConfParametrosServ(ReqServConfig).Rows)
                    {
                        //aqui se cambio Actualizacion 28/01/2014:
                        NroRecibo = blCCItem.Ins_CtaCteItem(CodEmpresa, cPerCodigo, nPeriodo, row["nCtaCteTipoCta"].ToString(), dFechaSys.Year, Convert.ToDouble(fila["nSysValor"]), dFechaSys, 1);

                        nLinea = blCCItemLine.Ins_CtaCteIteLine(CodEmpresa, cPerCodigo, NroRecibo, Convert.ToInt32(fila["nParCodigo_nCtaCteSerCodigo"]), Convert.ToInt32(fila["nMonCodigo"]), 1, Convert.ToDouble(fila["nSysValor"]), Convert.ToDouble(fila["nSysValor"]), nTC, 1);

                        if (nLinea != 0)
                        {
                            //---------------------
                            //CtaCteIteLinRetencion
                            //---------------------
                            foreach (DataRow posicion in blImpServ.Get_ImpuestoServicio(CodEmpresa, cPerCodigo, NroRecibo, Convert.ToInt32(fila["nParCodigo_nCtaCteSerCodigo"]), 9256).Rows) //9256.- Perú
                            {
                                if (!blCCRetencion.Ins_CtaCteIteLinRetencion(CodEmpresa, cPerCodigo, NroRecibo, nLinea, Convert.ToInt32(posicion["nSysTasCodigo"]), Convert.ToDouble(fila["nSysValor"]), Convert.ToInt32(posicion["fSysTasValor"]), dFechaSys))
                                {
                                    throw new ApplicationException("Se encontraron errores en la transaccion: Ins_CtaCteIteLinRetencion.!");
                                }
                            }
                        }
                        else
                        {
                            throw new ApplicationException("Se encontraron errores en la transaccion: Ins_CtaCteIteLine.!");
                        }
                    }

                    //------------------------------------------------------------------------------
                    //update AdmSolicitud (cCtaCteRecibo) - Referenciando recibo en "AdmSolicitud" ?
                    //------------------------------------------------------------------------------
                    if (!DaSolAdm.Upd_AdmSol_cCtaCteRecibo(CodEmpresa, TipoPrograma, NroSolicitud, NroRecibo))
                    {
                        throw new ApplicationException("Se encontraron errores en la transaccion: AdmSolicitud.! " + CodEmpresa + ' ' + TipoPrograma + ' ' + NroSolicitud + ' ' + NroRecibo);
                    }

                    //exito = true;
                    //tx.Complete();

                    /* Perform transactional work here */
                    //No errors - commit transaction
                    committableTransaction.Commit();
                    exito = true;
                }

                else
                {
                    throw new ApplicationException("Configuracion de parametros no establecida.!");
                }
            }
            //}
            catch (Exception)
            {
                committableTransaction.Rollback();
                throw;
            }
            finally
            {
                committableTransaction.Dispose();
                //Restore the ambient transaction
                Transaction.Current = oldAmbient;
            }

            return(exito);
        }
コード例 #53
0
        public void ExplicitTransaction6a()
        {
            Assert.Throws<InvalidOperationException>(() =>
            {
                CommittableTransaction ct = new CommittableTransaction();

                IntResourceManager irm = new IntResourceManager(1);
                irm.Value = 2;
                ct.Commit();

                /* Using a already committed transaction in a new 
                 * TransactionScope
                 */
                TransactionScope scope = new TransactionScope(ct);
            });
        }
コード例 #54
0
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //  thread per endpoint batch
        private void BatchWorker(string outboundTransportLocation, ArrayList messages)
        {
            //  we did an enter for every message - so we should ensure we have a correspending leave
            int leaveCount = messages.Count;

            try
            {
                //  all the messages in this batch should have the same properties - so just take the first one
                IBaseMessage                    firstMessage        = (IBaseMessage)messages[0];
                SystemMessageContext            firstMessageContext = new SystemMessageContext(firstMessage.Context);
                TransactionalTransmitProperties properties          = new TransactionalTransmitProperties(firstMessageContext.OutboundTransportLocation);

                string config = (string)firstMessage.Context.Read("AdapterConfig", this.propertyNamespace);
                if (config != null)
                {
                    // There is a configuration DOM so we are doing a Static Send
                    XmlDocument locationConfigDom = new XmlDocument();
                    locationConfigDom.LoadXml(config);
                    properties.LocationConfiguration(locationConfigDom);
                }
                else
                {
                    // Add dynamic send here
                }

                foreach (IBaseMessage message in messages)
                {
                    CommittableTransaction transaction = null;

                    try
                    {
                        //  create the System.Transactions transaction - this is not yet a DTC transaction
                        transaction = new CommittableTransaction();

                        //  give the CommittableTransaction to the batch and it will take the responsibility to Commit it.
                        //  the TransactionInterop.GetDtcTransaction call inside the base TxnBase class actually causes the
                        //  DTC transaction to be created - this can be observed in the COM+ Explorer while debugging this code
                        using (Batch batch = new TransactionalDeleteBatch(this.transportProxy, this.control, transaction))
                        {
                            //  note the options EnterpriseServicesInteropOption.Full in the future when resource managers
                            //  understand light weight transactions this might not be necessary but we need it for now
                            using (TransactionScope ts = new TransactionScope(transaction, TimeSpan.FromHours(1), EnterpriseServicesInteropOption.Full))
                            {
                                SendMessage(message, properties);

                                //  an exception will skip this next line
                                ts.Complete();
                            }

                            //  IMPORTANT: a Delete is part of the same transaction as the send operation
                            batch.DeleteMessage(message);

                            //  IMPORTANT: if there was a response to submit it would be added here
                            //  - in the same batch and same transaction as the Delete

                            batch.Done();
                        }
                    }
                    catch (Exception e)
                    {
                        // in this scenario we will explicitly Rollback the transaction on failure
                        if (transaction != null)
                        {
                            transaction.Rollback();
                        }

                        //  Remember to set the exception on the message itself - this will now appear in tracking in addition to the EventLog
                        message.SetErrorInfo(e);

                        //  Any failures need to be retried - but the change of state back on BizTalk is outside of the transaction
                        //  that has been used to attempt to send the message - after all that transaction will undoubtedly get rollback with the failure.
                        //  We say this batch is "non-transactional" from the adapter's point of view - though internally in BizTalk its still a transaction.
                        using (TransmitResponseBatch batch = new TransmitResponseBatch(this.transportProxy, new TransmitResponseBatch.AllWorkDoneDelegate(AllWorkDone)))
                        {
                            batch.Resubmit(message, false, null);
                            batch.Done();
                        }
                    }

                    // an exception will skip this line - an exception means the Done hasn't been called or was successful so we have a leave to do
                    leaveCount--;
                }
            }
            catch (Exception e)
            {
                this.transportProxy.SetErrorInfo(e);
            }
            finally
            {
                // perform any remain leaves - hopefully none - if everything was successful then leaveCount will be 0
                for (int i = 0; i < leaveCount; i++)
                {
                    this.control.Leave();
                }
            }
        }
コード例 #55
0
        public void ExplicitTransaction6e()
        {
            CommittableTransaction ct = new CommittableTransaction();

            IntResourceManager irm = new IntResourceManager(1);

            Transaction.Current = ct;
            try
            {
                TransactionScope scope1 = new TransactionScope();
                /* Enlist */
                irm.Value = 2;

                TransactionScope scope2 = new TransactionScope(TransactionScopeOption.Suppress);
                Assert.Throws<InvalidOperationException>(() => scope1.Dispose());
                scope2.Dispose();
            }
            finally
            {
                Transaction.Current = null;
            }
        }
コード例 #56
0
        public void CanUseSessionWithManyDependentTransaction(bool explicitFlush)
        {
            if (!TestDialect.SupportsDependentTransaction)
            {
                Assert.Ignore("Dialect does not support dependent transactions");
            }
            IgnoreIfUnsupported(explicitFlush);

            try
            {
                using (var s = Sfi.WithOptions().ConnectionReleaseMode(ConnectionReleaseMode.OnClose).OpenSession())
                {
                    using (var committable = new CommittableTransaction())
                    {
                        System.Transactions.Transaction.Current = committable;
                        using (var clone = committable.DependentClone(DependentCloneOption.RollbackIfNotComplete))
                        {
                            System.Transactions.Transaction.Current = clone;
                            if (!AutoJoinTransaction)
                            {
                                s.JoinTransaction();
                            }
                            // Acquire the connection
                            var count = s.Query <Person>().Count();
                            Assert.That(count, Is.EqualTo(0), "Unexpected initial entity count.");
                            clone.Complete();
                        }

                        using (var clone = committable.DependentClone(DependentCloneOption.RollbackIfNotComplete))
                        {
                            System.Transactions.Transaction.Current = clone;
                            if (!AutoJoinTransaction)
                            {
                                s.JoinTransaction();
                            }
                            s.Save(new Person());

                            if (explicitFlush)
                            {
                                s.Flush();
                            }

                            clone.Complete();
                        }

                        using (var clone = committable.DependentClone(DependentCloneOption.RollbackIfNotComplete))
                        {
                            System.Transactions.Transaction.Current = clone;
                            if (!AutoJoinTransaction)
                            {
                                s.JoinTransaction();
                            }
                            var count = s.Query <Person>().Count();
                            Assert.That(count, Is.EqualTo(1), "Unexpected entity count after committed insert.");
                            clone.Complete();
                        }

                        System.Transactions.Transaction.Current = committable;
                        committable.Commit();
                    }
                }
            }
            finally
            {
                System.Transactions.Transaction.Current = null;
            }

            DodgeTransactionCompletionDelayIfRequired();

            using (var s = OpenSession())
            {
                using (var tx = new TransactionScope())
                {
                    if (!AutoJoinTransaction)
                    {
                        s.JoinTransaction();
                    }
                    var count = s.Query <Person>().Count();
                    Assert.That(count, Is.EqualTo(1), "Unexpected entity count after global commit.");
                    tx.Complete();
                }
            }
        }
コード例 #57
0
        public void ExplicitTransaction8a()
        {
            CommittableTransaction ct = new CommittableTransaction();

            IntResourceManager irm = new IntResourceManager(1);
            using (TransactionScope scope = new TransactionScope(ct))
            {
                irm.Value = 2;
                scope.Complete();
                Assert.Throws<TransactionAbortedException>(() => ct.Commit()); /* FIXME: Why TransactionAbortedException ?? */
                irm.Check(0, 0, 1, 0, "irm");
            }
        }
コード例 #58
0
 /// <summary>
 ///
 /// </summary>
 public void ReSet()
 {
     _ct   = new CommittableTransaction(_ops);
     _done = false;
 }
コード例 #59
0
        public void ExplicitTransaction12()
        {
            Assert.Throws<ArgumentException>(() =>
            {
                CommittableTransaction ct = new CommittableTransaction();

                IntResourceManager irm = new IntResourceManager(1);
                irm.FailPrepare = true;
                ct.BeginCommit(null, null);
                ct.EndCommit(null);
            });
        }
コード例 #60
0
        // These variations need to be added once we have promotion support.

        /*
         * [InlineData(CloneType.Normal, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.RepeatableRead, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.ReadCommitted, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.ReadUncommitted, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Snapshot, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Chaos, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, IsolationLevel.Unspecified, false, TransactionStatus.Committed)]
         * [InlineData(CloneType.Normal, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Serializable, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.RepeatableRead, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadCommitted, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadUncommitted, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Snapshot, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Chaos, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.BlockingDependent, IsolationLevel.Unspecified, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Serializable, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.RepeatableRead, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadCommitted, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadUncommitted, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Snapshot, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Chaos, true, TransactionStatus.Committed)]
         * [InlineData(CloneType.RollbackDependent, IsolationLevel.Unspecified, true, TransactionStatus.Committed)]
         */
        public void Run(CloneType cloneType, IsolationLevel isoLevel, bool forcePromote, TransactionStatus expectedStatus)
        {
            TransactionOptions options = new TransactionOptions
            {
                IsolationLevel = isoLevel,
                // Shorten the delay before a timeout for blocking clones.
                Timeout = TimeSpan.FromSeconds(1)
            };

            // If we are dealing with a "normal" clone, we fully expect the transaction to commit successfully.
            // But a timeout of 1 seconds may not be enough for that to happen. So increase the timeout
            // for "normal" clones. This will not increase the test execution time in the "passing" scenario.
            if (cloneType == CloneType.Normal)
            {
                options.Timeout = TimeSpan.FromSeconds(10);
            }

            CommittableTransaction tx = new CommittableTransaction(options);

            Transaction clone;

            switch (cloneType)
            {
            case CloneType.Normal:
            {
                clone = tx.Clone();
                break;
            }

            case CloneType.BlockingDependent:
            {
                clone = tx.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
                break;
            }

            case CloneType.RollbackDependent:
            {
                clone = tx.DependentClone(DependentCloneOption.RollbackIfNotComplete);
                break;
            }

            default:
            {
                throw new Exception("Unexpected CloneType - " + cloneType.ToString());
            }
            }

            if (forcePromote)
            {
                HelperFunctions.PromoteTx(tx);
            }

            Assert.Equal(tx.IsolationLevel, clone.IsolationLevel);
            Assert.Equal(tx.TransactionInformation.Status, clone.TransactionInformation.Status);
            Assert.Equal(tx.TransactionInformation.LocalIdentifier, clone.TransactionInformation.LocalIdentifier);
            Assert.Equal(tx.TransactionInformation.DistributedIdentifier, clone.TransactionInformation.DistributedIdentifier);

            CommittableTransaction cloneCommittable = clone as CommittableTransaction;

            Assert.Null(cloneCommittable);

            try
            {
                tx.Commit();
            }
            catch (TransactionAbortedException ex)
            {
                Assert.Equal(TransactionStatus.Aborted, expectedStatus);
                switch (cloneType)
                {
                case CloneType.Normal:
                {
                    // We shouldn't be getting TransactionAbortedException for "normal" clones,
                    // so we have these two Asserts to possibly help determine what went wrong.
                    Assert.Null(ex.InnerException);
                    Assert.Equal("There shouldn't be any exception with this Message property", ex.Message);
                    break;
                }

                case CloneType.BlockingDependent:
                {
                    Assert.IsType <TimeoutException>(ex.InnerException);
                    break;
                }

                case CloneType.RollbackDependent:
                {
                    Assert.Null(ex.InnerException);
                    break;
                }

                default:
                {
                    throw new Exception("Unexpected CloneType - " + cloneType.ToString());
                }
                }
            }

            Assert.Equal(expectedStatus, tx.TransactionInformation.Status);
        }