Ejemplo n.º 1
0
        static void Main(string[] args)
        {
            TMParser parser = new TMParser();

            if (!parser.Parse(args))
            {
                return;
            }

            var serverProv = new SoapServerFormatterSinkProvider {
                TypeFilterLevel = TypeFilterLevel.Full
            };

            var clientProv = new SoapClientFormatterSinkProvider();

            IDictionary props = new Hashtable();

            props["port"] = Int32.Parse(parser["p"]);

            var channel = new HttpChannel(props, clientProv, serverProv);

            ChannelServices.RegisterChannel(channel, false);

            RemotingConfiguration.RegisterWellKnownServiceType
                (Type.GetType("MyTM.MyTM")                              // full type name
                , "TM.soap"                                             // URI
                , System.Runtime.Remoting.WellKnownObjectMode.Singleton // instancing mode
                );

            while (true)
            {
                Thread.Sleep(2000);
                TwoPhaseCommit.PrintMessage();
            }
        }
Ejemplo n.º 2
0
 public MyTM()
 {
     Console.WriteLine("TM: Transaction Manager instantiated");
     // by default, the TwoPhaseCommit shall not have the debugging properties PrepareFail and CommitFail set
     TwoPhaseCommit.PrepareFail = false;
     TwoPhaseCommit.CommitFail  = false;
     TwoPhaseCommit.StartUp();
     _transactionScavengerThread = new Thread(TransactionScavenger)
     {
         Name = "TransactionScavengerThread"
     };
     _transactionScavengerThread.Start();
 }
Ejemplo n.º 3
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));
 }
Ejemplo n.º 4
0
        /// <summary>
        /// The method to do two phrase commit
        /// This method shall be hosted in a new thread.
        /// The caller can wait on the DoneEvent.
        /// </summary>
        public void StartCommit(bool prepareFail = false, bool commitFail = false)
        {
            this.prepareFail = prepareFail;
            this.commitFail  = commitFail;
            bool isStepComplete = false;
            var  list           = this.ResouceManagers.ResourceManagers;

            for (int i = 0; i < list.Count; i++)
            {
                rmCommitStates[i] = CommitState.Committed;
            }

            TwoPhaseCommit.WriteLog();
            Prepare();

            if ((isStepComplete = this.stepWaitEvent.WaitOne(stepTimeout)))
            {
                TwoPhaseCommit.WriteLog();
                isStepComplete = WaitStepWithExpBackoff(Commit);

                if (isStepComplete)
                {
                    TwoPhaseCommit.WriteLog();
                    TwoPhaseCommit.DoneCommit(this.Context);
                    DoneEvent.Set();
                }
                else
                {
                    string outstring = string.Format("2PC:Retry Commit {0}\r", this.Context.Id);
                    this.Message += outstring;
                    Console.Write(string.Format("2PC:Retry Commit {0}\r", this.Context.Id));
                    WaitStepWithExpBackoff(Commit);
                }
            }
            else
            {
                // Presume abort
                Rollback();
                TwoPhaseCommit.WriteLog();
                TwoPhaseCommit.DoneCommit(this.Context);
                DoneEvent.Set();
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// TM shall call this function when it restarts.
        /// if return is true
        ///     1. TM shall delete the transaction or retry commit if the state after recover is Rollbacked.
        ///     2. TM shall delete the transaction if the state after recover is done;
        /// if return is false
        ///     TM shall retry the recover process;
        /// </summary>
        /// <return>false if the recover process failed.</return>
        public bool Recover()
        {
            foreach (RM rm in this.ResouceManagers.ResourceManagers)
            {
                RM inTM = null;
                while (inTM == null)
                {
                    try
                    {
                        inTM = MyTM.StaticGetResourceMananger(rm.GetName());
                    }
                    catch (WebException)
                    {
                    }

                    if (inTM == null)
                    {
                        MyTM.StaticRegister(rm);
                    }
                }
            }
            switch (State)
            {
            case CommitState.Committed:
                Rollback();
                TwoPhaseCommit.WriteLog();
                break;

            case CommitState.Prepared:
                Commit();
                TwoPhaseCommit.WriteLog();
                break;

            default:
                this.stepWaitEvent.Set();
                break;
            }

            return(this.stepWaitEvent.WaitOne(stepTimeout));
        }