Esempio n. 1
0
        /// <param name="c">Customer</param>
        /// <param name="flights">array of flight names</param>
        /// <param name="location">room location if room is true</param>
        /// <param name="car">true if request is for a car</param>
        /// <param name="room">true if request is for a room</param>
        /// <returns>price of reservation</returns>
        public bool ReserveItinerary(TP.Customer c, string[] flights, string location, bool car, bool room)
        {
            TP.Transaction tid = TransactionManager.Start();

            try
            {
                if (car)
                {
                    Cars.Reserve(tid, c, RID.forCar(location));
                }

                if (room)
                {
                    Rooms.Reserve(tid, c, RID.forRoom(location));
                }

                foreach (string flight in flights)
                {
                    Flights.Reserve(tid, c, RID.forFlight(flight));
                }

                TransactionManager.Commit(tid);
            }
            catch (Exception e)
            {
                TransactionManager.Abort(tid);
                throw;
            }
            return(true);
        }
Esempio n. 2
0
            /// <summary>

            /*  Release a lock of mode _request_ for transaction _context_
             *  Return if context does not hold a lock for this resource */
            /// </summary>
            public void Unregister(TP.Transaction context, LockMode request)
            {
                // First get the hash table for this lock mode
                System.Collections.Hashtable transactionList = this.transactions[(int)request];

                if (transactionList == null || transactionList[context] == null)
                {
                    // This transaction wasn't registered, return immediately
                    return;
                }

                transactionList.Remove(context);

                for (LockMode l = locked; l > LockMode.Null; locked = --l)
                {
                    // recalculate the strongest lock mode
                    System.Collections.Hashtable nextTransactionList = this.transactions[(int)l];
                    if (nextTransactionList == null)
                    {
                        continue;
                    }
                    if (nextTransactionList.Count > 0)
                    {
                        break;
                    }
                }

                // common case plus special case where we want to convert a read lock to write lock
                if (request > locked || (this.locked == LockMode.Update && this.transactions[(int)LockMode.Read].Count == 0))
                {
                    // if anyone was waiting for this lock, they should recheck
                    this.UnlockEvent.Set();
                }
            }
Esempio n. 3
0
            // Upgrade a read lock to a write lock for the specified transaction.
            // Returns true if the conversion is successful, returns false otherwise.
            public bool UpgradeLockRequest(TP.Transaction context, LockMode request)
            {
                // There is no need to upgrade the lock if it is not a write request or if the resource is not locked
                if (request != LockMode.Write || locked == LockMode.Null)
                {
                    return(false);
                }

                // First, deal with the case when the resouce is write-locked
                if (locked == LockMode.Write)
                {
                    System.Collections.Hashtable writeTransactionList = this.transactions[(int)LockMode.Write];

                    // Assume that the write transaction list is not null when the current lock mode is Write
                    if (writeTransactionList == null)
                    {
                        throw new System.ApplicationException("Write transaction list is null even when lock mode is write");
                    }

                    // There is no need to do anywork if the transaction already has a write lock on the resource.
                    if (writeTransactionList[context] != null)
                    {
                        return(true);
                    }
                    // The lock can't be upgraded if another transaction has a write lock on the resource
                    else if (writeTransactionList.Count > 0)
                    {
                        return(false);
                    }
                }
                // Deal with the case when the resource is read-locked
                else
                {
                    // Get the list of transactions that hold a read lock on the resource
                    System.Collections.Hashtable readTransactionList = this.transactions[(int)LockMode.Read];

                    // Assume that the read transaction list is not null when the current lock mode is Write
                    // since the transaction should already have a read lock on the resource.
                    if (readTransactionList == null)
                    {
                        throw new System.ApplicationException("Read transaction list is null even when lock mode is read");
                    }

                    // We can upgrade the lock only if the transaction is the only one that has a read lock on the resource
                    if (readTransactionList.Count == 1 && readTransactionList[context] != null)
                    {
                        // Acquire the write lock for this resource before releasing the read lock to ensure two-phase locking
                        Register(context, LockMode.Write);
                        Unregister(context, LockMode.Read);
                        return(true);
                    }
                    // The lock can't be upgraded if another transaction has a read lock on the resource
                    else
                    {
                        return(false);
                    }
                }

                return(false);
            }
Esempio n. 4
0
        public bool CancelItinerary(Customer customer)
        {
            TP.Transaction tid = TransactionManager.Start();
            try
            {
                if (Flights != null)
                {
                    Flights.UnReserve(tid, customer);
                }

                if (Cars != null)
                {
                    Cars.UnReserve(tid, customer);
                }

                if (Rooms != null)
                {
                    Rooms.UnReserve(tid, customer);
                }

                TransactionManager.Commit(tid);
            }
            catch (Exception e)
            {
                TransactionManager.Abort(tid);
                throw new Exception("caught an exception", e);
            }
            return(true);
        }
Esempio n. 5
0
        // Unlock all resources for the passed in transaction
        public void UnlockAll(TP.Transaction context)
        {
            // Loop over the resources
            lock (this.ResourceTable)
            {
                // Get resource enumerator
                System.Collections.IDictionaryEnumerator resenum = ResourceTable.GetEnumerator();

                // Loop over resources
                while (resenum.MoveNext())
                {
                    ResourceEntry lockTarget = (ResourceEntry)resenum.Value;
                    lock (lockTarget)
                    {
                        // Unregister all unlock modes for current resource
                        for (int lockMode = (int)LockMode.Read; lockMode < (int)LockMode._Length; lockMode++)
                        {
                            lockTarget.Unregister(context, (LockMode)lockMode);
                        }
                    }
                }
            }

            System.Console.WriteLine("----Unlocked all for Tx: {0}--------", context.Id);
        }
Esempio n. 6
0
            /* Add a lock of type _request_ for transaction _context_ */
            public void Register(TP.Transaction context, LockMode request)
            {
                // First get the hash table for this lock mode on this resource entry, if it exists
                System.Collections.Hashtable transactionList = this.transactions[(int)request];

                // If there is no hash table for this lock mode, create one
                if (transactionList == null)
                {
                    transactionList = new System.Collections.Hashtable();
                    this.transactions[(int)request] = transactionList;
                }

                // Add the transaction to the list for _request_ lock mode
                transactionList[context] = context;

                // Update the strongest lock mode, if necessary
                if (request > locked)
                {
                    locked = request;
                }

                if (evnt != null)
                {
                    evnt.Reset();
                }
            }
Esempio n. 7
0
        /*  Called by RM.
         *  This method notifies TM that it is involved in a given transaction
         *  TM keeps track of which RM is enlisted with which transaction to do distributed transactions */
        /// <summary>
        /// </summary>
        /// <param name="context"></param>
        /// <param name="enlistingRM"> </param>
        public bool Enlist(TP.Transaction context, string enlistingRM)
        {
            var rm = GetResourceMananger(enlistingRM);

            if (rm == null)
            {
                throw new ApplicationException(enlistingRM + " not registered.");
            }

            lock (_resourceManagersEnlistedInTransactions)
            {
                if (_resourceManagersEnlistedInTransactions.ContainsKey(context))
                {
                    var list = _resourceManagersEnlistedInTransactions[context];

                    if (!list.Contains(rm))
                    {
                        _resourceManagersEnlistedInTransactions[context].Add(rm);
                    }
                }
                else
                {
                    _resourceManagersEnlistedInTransactions.Add(context, new ResourceManagerList(rm));
                }
            }

            Console.WriteLine(string.Format("TM: Transaction {0} enlisted for {1}", context.Id, enlistingRM));
            return(true);
        }
Esempio n. 8
0
        public void AddSeatsTwoTransactions()
        {
            var wc = new MyWC.MyWC_Accessor();
            var tm = new MyTM.MyTM();
            var rm = new MyRM.MyRM();

            MyWC_Accessor.TransactionManager = tm;
            rm.SetName("flight");
            rm.TransactionManager = tm;
            tm.Register(rm);
            MyWC.MyWC.Flights = tm.GetResourceMananger("flight");

            var context1 = new Transaction();
            var context2 = new Transaction();

            wc.AddSeats(context1, "FL_C", 100, 550);
            wc.AddSeats(context2, "SG_A", 200, 250);
            wc.Abort(context2);
            wc.Commit(context1);

            context1 = new Transaction();
            var result = wc.ListFlights(context1);

            wc.Commit(context1);
            Assert.IsTrue((from f in result where f == "FL_C,100,550" select f).Any());
            Assert.IsFalse((from f in result where f == "SG_A,200,250" select f).Any());
        }
Esempio n. 9
0
            /* Add a lock of type _request_ for transaction _context_ */
            public void Register(TP.Transaction context, LockMode request)
            {
                // First get the hash table for this lock mode on this resource entry, if it exists
                System.Collections.Hashtable transactionList = this.transactions[(int)request];

                // If there is no hash table for this lock mode, create one
                if (transactionList == null)
                {
                    transactionList = new System.Collections.Hashtable();
                    this.transactions[(int)request] = transactionList;
                }

                // Add the transaction to the list for _request_ lock mode
                transactionList[context] = context;

                // Update the strongest lock mode, if necessary
                if (request > locked)
                {
                    locked = request;
                }

                // If we set locked mode to Update lock mode, we do not reset
                // the event because we still want to track the read locks.
                if (request != LockMode.Update)
                {
                    this.UnlockEvent.Reset();
                }
            }
Esempio n. 10
0
 // Commit the specified transaction
 public void Commit(TP.Transaction context)
 {
     if (commitFailure)
     {
         // Sleep forever if simulate failure flag is set
         Thread.Sleep(System.Threading.Timeout.Infinite);
     }
     // commit transaction
     this.dataStore.Commit(context);
 }
Esempio n. 11
0
            // Checks whether the lock request will potentially downgrade the lock for the specified transaction.
            // Returns true if the request is read lock and specified transaction already has a write lock on the resource
            public bool DownGradedLockRequest(TP.Transaction context, LockMode request)
            {
                System.Collections.Hashtable transactionList = this.transactions[(int)LockMode.Write];
                if (request == LockMode.Read && (transactionList != null && transactionList[context] != null))
                {
                    return(true);
                }

                return(false);
            }
Esempio n. 12
0
        public void CancelSingleFlight()
        {
            var wc  = new MyWC.MyWC_Accessor();
            var tm  = new MyTM.MyTM();
            var rmf = new MyRM.MyRM();
            var rmc = new MyRM.MyRM();
            var rmr = new MyRM.MyRM();

            MyWC_Accessor.TransactionManager = tm;

            rmf.SetName("flight");
            rmf.TransactionManager = tm;

            rmc.SetName("car");
            rmc.TransactionManager = tm;

            rmr.SetName("room");
            rmr.TransactionManager = tm;

            tm.Register(rmf);
            tm.Register(rmc);
            tm.Register(rmr);

            MyWC.MyWC.Flights            = tm.GetResourceMananger("flight");
            MyWC.MyWC.Cars               = tm.GetResourceMananger("car");
            MyWC.MyWC.Rooms              = tm.GetResourceMananger("room");
            MyWC.MyWC.TransactionManager = tm;

            var context = new Transaction();

            wc.AddSeats(context, "SEA-JFK", 1000, 200);
            wc.Commit(context);

            var c1 = new Customer();

            Assert.IsTrue(wc.ReserveItinerary(c1, new[] { "SEA-JFK" }, "NY", false, false));

            context = new Transaction();
            Assert.AreEqual(c1, wc.ListCustomers(context)[0]);
            Assert.IsFalse(String.IsNullOrEmpty(wc.QueryItinerary(context, c1)), "Itinerary not found");
            wc.Commit(context);

            context = new Transaction();
            Assert.AreEqual(1000 - 1, wc.QueryFlight(context, "SEA-JFK"));
            wc.Commit(context);

            wc.CancelItinerary(c1);

            context = new Transaction();
            Assert.AreEqual(1000, wc.QueryFlight(context, "SEA-JFK"));
            wc.Commit(context);
        }
Esempio n. 13
0
        /// <summary>
        /// Currently does not involve TM, will do it in later step
        /// </summary>
        /// <param name="context"></param>
        public XaResponse Abort(TP.Transaction context)
        {
            WaitForReady();

            ++NumberAborts;
            if (NumberAborts >= this.VoteNoOnAbort && this.VoteNoOnAbort != 0)
            {
                return(XaResponse.XAER_RMERR);
            }
            _transactionStorage.Abort(context);
            _lockManager.UnlockAll(context);
            return(XaResponse.XA_OK);
        }
Esempio n. 14
0
 /// <summary>
 ///	 Call from WC in response to a client's commit
 /// </summary>
 /// <param name="context"></param>
 public void Commit(TP.Transaction context)
 {
     WaitTillReady();
     lock (_resourceManagersEnlistedInTransactions)
     {
         if (_resourceManagersEnlistedInTransactions.ContainsKey(context))
         {
             CommitedTransaction trans = TwoPhaseCommit.Commit(context, _resourceManagersEnlistedInTransactions[context]);
             trans.DoneEvent.WaitOne(TransactionTimeout * 1000);
             _resourceManagersEnlistedInTransactions.Remove(context);
         }
     }
     Console.WriteLine(string.Format("TM: Transaction {0} commited", context.Id));
 }
Esempio n. 15
0
        /// <summary>
        /// Queries the # of given resource
        /// </summary>
        /// <param name="context"></param>
        /// <param name="rid"></param>
        /// <returns>returns the amount available for the specified item type */</returns>
        public int Query(TP.Transaction context, RID rid)
        {
            WaitForReady();
            Enlist(context);

            _lockManager.LockForRead(context, rid);
            Console.WriteLine("RM: Query");
            Resource resource = _transactionStorage.Read(context, rid);

            if (resource == null)
            {
                throw new ArgumentException(rid + " does not exist");
            }

            return(resource.getCount());
        }
Esempio n. 16
0
        // This function returns the list of RMs associated with the given transaction and
        // automatically removes the given transaction from the active transaction list
        private List <string> GetRMListForTransaction(TP.Transaction context)
        {
            List <string> output = null;

            lock (this.activeTransactions)
            {
                if (!this.activeTransactions.TryGetValue(context, out output))
                {
                    // nothing to do transaction must already have been commited
                    return(null);
                }

                // remove from list
                this.activeTransactions.Remove(context);
            }

            return(output);
        }
Esempio n. 17
0
 /// <summary>
 /// Currently does not involve TM, will do it in later step
 /// Call to TM to enlist for distributed transaction
 /// </summary>
 /// <param name="context"></param>
 public void Enlist(TP.Transaction context)
 {
     WaitForReady();
     try
     {
         _transactionManager.Enlist(context, this.GetName());
         return;
     }
     catch (WebException)
     {
     }
     catch (ApplicationException)
     {
     }
     _transactionManager = null;
     ReconnectToTM();
     WaitForReady();
 }
Esempio n. 18
0
        public void AddDeleteCombinationsOneByOne()
        {
            var wc  = new MyWC.MyWC_Accessor();
            var tm  = new MyTM.MyTM();
            var rmf = new MyRM.MyRM();
            var rmc = new MyRM.MyRM();
            var rmr = new MyRM.MyRM();

            MyWC_Accessor.TransactionManager = tm;

            rmf.SetName("flight");
            rmf.TransactionManager = tm;

            rmc.SetName("car");
            rmc.TransactionManager = tm;

            rmr.SetName("room");
            rmr.TransactionManager = tm;

            tm.Register(rmf);
            tm.Register(rmc);
            tm.Register(rmr);

            MyWC.MyWC.Flights = tm.GetResourceMananger("flight");
            MyWC.MyWC.Cars    = tm.GetResourceMananger("car");
            MyWC.MyWC.Rooms   = tm.GetResourceMananger("room");

            var context = new Transaction();

            wc.AddSeats(context, "SEA-JFK", 3000, 300);
            wc.Commit(context);
            wc.AddCars(context, "NY", 2000, 200);
            wc.Commit(context);
            wc.AddRooms(context, "NY", 1000, 100);
            wc.Commit(context);

            context = new Transaction();
            Assert.AreEqual(200, wc.QueryCarPrice(context, "NY"));
            Assert.AreEqual(300, wc.QueryFlightPrice(context, "SEA-JFK"));
            Assert.AreEqual(100, wc.QueryRoomPrice(context, "NY"));
            wc.Commit(context);
        }
Esempio n. 19
0
        /// <summary>
        // Call from WC in response to a client's abort
        /// </summary>
        /// <param name="context"></param>
        public void Abort(TP.Transaction context)
        {
            WaitTillReady();
            lock (_resourceManagersEnlistedInTransactions)
            {
                if (_resourceManagersEnlistedInTransactions.ContainsKey(context))
                {
                    var list = _resourceManagersEnlistedInTransactions[context].ResourceManagers;

                    foreach (RM r in list)
                    {
                        r.Abort(context);
                    }

                    _resourceManagersEnlistedInTransactions.Remove(context);
                }
            }

            Console.WriteLine(string.Format("TM: Transaction {0} aborted", context.Id));
        }
Esempio n. 20
0
        /// <summary>
        /// implemented using the new TransactionStorage class
        /// This method adds a resource to the available ones
        /// </summary>
        /// <param name="context"></param>
        /// <param name="i"></param>
        /// <param name="count"></param>
        /// <param name="price"></param>
        /// <returns></returns>
        public bool Add(TP.Transaction context, TP.RID i, int count, int price)
        {
            WaitForReady();
            Enlist(context);

            _lockManager.LockForWrite(context, i);
            Resource res = _transactionStorage.Read(context, i);

            if (res == null)
            {
                res = new Resource(i, count, price);
            }
            else
            {
                res.incrCount(count);
                res.setPrice(price);
            }

            _transactionStorage.Write(context, i, res);
            return(true);
        }
Esempio n. 21
0
        // Unlock a resource: find the entry and call unregister lock
        private void Unlock(TP.Transaction context, TP.Lockable resource, LockMode mode)
        {
            ResourceEntry lockTarget;

            // Get exclusive access to the lock table
            lock (this.ResourceTable)
            {
                this.ResourceTable.TryGetValue(resource, out lockTarget);

                // Check if the resource wasn't locked, and if so, then return
                if (lockTarget == null)
                {
                    return;
                }
            }

            // Get exclusive access to the resource
            lock (lockTarget)
            {
                lockTarget.Unregister(context, mode);
            }
        }
Esempio n. 22
0
        /// <summary>
        /// implemented using the new TransactionStorage class
        /// </summary>
        /// <param name="context"></param>
        /// <param name="rid"></param>
        /// <returns></returns>
        public bool Delete(TP.Transaction context, RID rid)
        {
            WaitForReady();
            Enlist(context);

            _lockManager.LockForWrite(context, rid);
            bool removed = _transactionStorage.Delete(context, rid);

            // drop all reservations on removed resource

            if (removed)
            {
                foreach (Customer c in _transactionStorage.GetCustomers(context))
                {
                    _lockManager.LockForWrite(context, c);
                    HashSet <RID> e = _transactionStorage.Read(context, c);
                    e.Remove(rid);
                    _transactionStorage.Write(context, c, e);
                }
            }

            return(removed);
        }
Esempio n. 23
0
            /// <summary>

            /*  Release a lock of mode _request_ for transaction _context_
             *  Return if context does not hold a lock for this resource */
            /// </summary>
            public void Unregister(TP.Transaction context, LockMode request)
            {
                // First get the hash table for this lock mode
                System.Collections.Hashtable transactionList = this.transactions[(int)request];

                if (transactionList == null || transactionList[context] == null)
                {
                    // This transaction wasn't registered, return immediately
                    return;
                }
                transactionList.Remove(context);

                locked = LockMode.Null;
                for (LockMode l = LockMode.Write; l > LockMode.Null; --l)
                {
                    // recalculate the strongest lock mode
                    System.Collections.Hashtable nextTransactionList = this.transactions[(int)l];
                    if (nextTransactionList == null)
                    {
                        continue;
                    }
                    if (nextTransactionList.Count > 0)
                    {
                        locked = l;
                        break;
                    }
                }

                if (request > locked)
                {
                    // if anyone was waiting for this lock, they should recheck
                    if (evnt != null)
                    {
                        evnt.Set();
                    }
                }
            }
Esempio n. 24
0
        /// <summary>
        /// Called by RM.
        /// This method notifies TM that it is involved in a given transaction
        /// TM keeps track of which RM is enlisted with which transaction to do distributed transactions */
        /// </summary>
        /// <param name="context"></param>
        public bool Enlist(TP.Transaction context, string enlistingRM)
        {
            // determine if this is an RM we know about
            this.ValidateRM(enlistingRM);

            lock (this.activeTransactions)
            {
                if (!this.activeTransactions.ContainsKey(context))
                {
                    // an RM is trying to enlist in a transaction
                    // the TM knows nothing about - return false
                    return(false);
                }

                // Add the RM to the active transaction only if it has not been added already
                if (!this.activeTransactions[context].Contains(enlistingRM))
                {
                    this.activeTransactions[context].Add(enlistingRM);
                }
            }

            System.Console.WriteLine(string.Format("Transaction {0} enlisted", context.Id));
            return(true);
        }
Esempio n. 25
0
        // Prepare the specified transaction
        public bool Prepare(TP.Transaction context)
        {
            // Returns false if failure mode is set to No
            if (prepareFailure == PrepareFailure.PrepareReturnsNo)
            {
                return(false);
            }
            // Sleep forever to simulate timeout if failure mode is set to TimesOut
            else if (prepareFailure == PrepareFailure.PrepareTimesOut)
            {
                Thread.Sleep(System.Threading.Timeout.Infinite);
            }

            // Otherwise, prepare the transaction and return the result - Prepared(true) or No(false)
            try
            {
                this.dataStore.Prepare(context);
            }
            catch (Exception)
            {
                return(false);
            }
            return(true);
        }
Esempio n. 26
0
        /// <param name="c">Customer</param>
        /// <param name="flights">array of flight names</param>
        /// <param name="location">room location if room is true</param>
        /// <param name="car">true if request is for a car</param>
        /// <param name="room">true if request is for a room</param>
        /// <returns>price of reservation</returns>
        public bool ReserveItinerary(TP.Customer c, string[] flights, string location, bool car, bool room)
        {
            TP.Transaction tid = TransactionManager.Start();

            try
            {
                if (car)
                {
                    bool result = Cars.Reserve(tid, c, RID.forCar(location));
                    if (!result)
                    {
                        throw new InvalidOperationException();
                    }
                }

                if (room)
                {
                    bool result = Rooms.Reserve(tid, c, RID.forRoom(location));
                    if (!result)
                    {
                        throw new InvalidOperationException();
                    }
                }

                foreach (string flight in flights)
                {
                    bool result = Flights.Reserve(tid, c, RID.forFlight(flight));
                    if (!result)
                    {
                        throw new InvalidOperationException();
                    }
                }

                Commit(tid);
            }
            catch (AbortTransationException)
            {
                Abort(tid);
                return(false);
            }
            catch (ArgumentException)
            {
                Abort(tid);
                return(false);
            }
            catch (DeadLockDetected)
            {
                Abort(tid);
                return(false);
            }
            catch (InvalidOperationException)
            {
                Abort(tid);
                return(false);
            }
            catch (Exception e)
            {
                Abort(tid);
                throw e;
            }

            return(true);
        }
Esempio n. 27
0
        public void AddDeleteCombinations()
        {
            var wc = new MyWC.MyWC_Accessor();
            var tm = new MyTM.MyTM();
            var rmf = new MyRM.MyRM();
            var rmc = new MyRM.MyRM();
            var rmr = new MyRM.MyRM();
            MyWC_Accessor.TransactionManager = tm;

            rmf.SetName("flight");
            rmf.TransactionManager = tm;

            rmc.SetName("car");
            rmc.TransactionManager = tm;

            rmr.SetName("room");
            rmr.TransactionManager = tm;

            tm.Register(rmf);
            tm.Register(rmc);
            tm.Register(rmr);

            MyWC.MyWC.Flights = tm.GetResourceMananger("flight");
            MyWC.MyWC.Cars = tm.GetResourceMananger("car");
            MyWC.MyWC.Rooms = tm.GetResourceMananger("room");

            var context = new Transaction();
            wc.AddSeats(context, "SEA-JFK", 3000, 300);
            wc.AddCars(context, "NY", 2000, 200);
            wc.AddRooms(context, "NY", 1000, 100);
            wc.Commit(context);

            context = new Transaction();
            Assert.AreEqual(200, wc.QueryCarPrice(context, "NY"));
            Assert.AreEqual(300, wc.QueryFlightPrice(context, "SEA-JFK"));
            Assert.AreEqual(100, wc.QueryRoomPrice(context, "NY"));
            wc.Commit(context);
        }
Esempio n. 28
0
        public void CancelSingleFlight()
        {
            var wc = new MyWC.MyWC_Accessor();
            var tm = new MyTM.MyTM();
            var rmf = new MyRM.MyRM();
            var rmc = new MyRM.MyRM();
            var rmr = new MyRM.MyRM();
            MyWC_Accessor.TransactionManager = tm;

            rmf.SetName("flight");
            rmf.TransactionManager = tm;

            rmc.SetName("car");
            rmc.TransactionManager = tm;

            rmr.SetName("room");
            rmr.TransactionManager = tm;

            tm.Register(rmf);
            tm.Register(rmc);
            tm.Register(rmr);

            MyWC.MyWC.Flights = tm.GetResourceMananger("flight");
            MyWC.MyWC.Cars = tm.GetResourceMananger("car");
            MyWC.MyWC.Rooms = tm.GetResourceMananger("room");
            MyWC.MyWC.TransactionManager = tm;

            var context = new Transaction();
            wc.AddSeats(context, "SEA-JFK", 1000, 200);
            wc.Commit(context);

            var c1 = new Customer();
            Assert.IsTrue(wc.ReserveItinerary(c1, new[] { "SEA-JFK" }, "NY", false, false));

            context = new Transaction();
            Assert.AreEqual(c1, wc.ListCustomers(context)[0]);
            Assert.IsFalse(String.IsNullOrEmpty(wc.QueryItinerary(context, c1)), "Itinerary not found");
            wc.Commit(context);

            context = new Transaction();
            Assert.AreEqual(1000 - 1, wc.QueryFlight(context, "SEA-JFK"));
            wc.Commit(context);

            wc.CancelItinerary(c1);

            context = new Transaction();
            Assert.AreEqual(1000, wc.QueryFlight(context, "SEA-JFK"));
            wc.Commit(context);
        }
Esempio n. 29
0
        public void AddSeatsTwoTransactions()
        {
            var wc = new MyWC.MyWC_Accessor();
            var tm = new MyTM.MyTM();
            var rm = new MyRM.MyRM();
            MyWC_Accessor.TransactionManager = tm;
            rm.SetName("flight");
            rm.TransactionManager = tm;
            tm.Register(rm);
            MyWC.MyWC.Flights = tm.GetResourceMananger("flight");

            var context1 = new Transaction();
            var context2 = new Transaction();
            wc.AddSeats(context1, "FL_C", 100, 550);
            wc.AddSeats(context2, "SG_A", 200, 250);
            wc.Abort(context2);
            wc.Commit(context1);

            context1 = new Transaction();
            var result = wc.ListFlights(context1);
            wc.Commit(context1);
            Assert.IsTrue((from f in result where f == "FL_C,100,550" select f).Any());
            Assert.IsFalse((from f in result where f == "SG_A,200,250" select f).Any());
        }
Esempio n. 30
0
 // A shortcut to unlock a write lock
 public void UnlockWrite(TP.Transaction context, TP.Lockable resource)
 {
     Unlock(context, resource, LockMode.Write);
 }
Esempio n. 31
0
 // A shortcut to unlock a read lock
 public void UnlockRead(TP.Transaction context, TP.Lockable resource)
 {
     Unlock(context, resource, LockMode.Read);
 }
Esempio n. 32
0
 // Get a write lock for the resource
 public void LockForWrite(TP.Transaction context, TP.Lockable resource)
 {
     Lock(context, resource, MyLM.LockMode.Write);
 }
Esempio n. 33
0
 // Get a read lock for the resource
 public void LockForRead(TP.Transaction context, TP.Lockable resource)
 {
     Lock(context, resource, MyLM.LockMode.Read);
 }