Пример #1
0
        public void DistributorTimeoutCache_GetUpdate()
        {
            var cache = new DistributorTimeoutCache(TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(500));

            var ev = new InnerData(new Transaction("123", ""))
            {
                Transaction = { Destination = new List <ServerId>() }
            };

            cache.AddToCache("123", ev.Transaction);
            var ret = cache.Get("123");

            Assert.AreEqual(ev.Transaction, ret);
            ev.Transaction.Complete();
            cache.Update("123", ev.Transaction);
            ret = cache.Get("123");
            Assert.AreEqual(ev.Transaction, ret);
            Thread.Sleep(200);
            ret = cache.Get("123");
            Assert.AreEqual(ev.Transaction, ret);
            Assert.AreEqual(TransactionState.Complete, ev.Transaction.State);
            Thread.Sleep(500);
            ret = cache.Get("123");
            Assert.AreEqual(null, ret);
        }
Пример #2
0
        public void ProcessWithData(InnerData data, TransactionExecutor executor)
        {
            Logger.Logger.Instance.Debug(string.Format("Mainlogic: process data = {0}", data.Transaction.EventHash));

            var dest = _distributor.GetDestination(data, GetCountServers(data));

            if (dest == null)
            {
                Logger.Logger.Instance.Debug(string.Format("Mainlogic: dont found destination, process data = {0}",
                                                           data.Transaction.EventHash));
                data.Transaction.SetError();
                data.Transaction.AddErrorDescription(Errors.NotAvailableServersForWrite);
            }
            else
            {
                data.Transaction.Destination = new List <ServerId>(dest);
            }
            if (data.Transaction.OperationName != OperationName.Read)
            {
                _cache.AddToCache(data.Transaction.CacheKey, data.Transaction);
            }
            if (!data.Transaction.IsError)
            {
                data.Transaction.Distributor = _distributor.LocalForDb;

                _transaction.ProcessSyncWithExecutor(data, executor);

                if (data.Transaction.IsError)
                {
                    if (data.Transaction.OperationName != OperationName.Read)
                    {
                        _cache.Update(data.Transaction.CacheKey, data.Transaction);
                    }
                    if (data.Transaction.OperationType == OperationType.Sync)
                    {
                        ProcessSyncTransaction(data.Transaction);
                    }
                }
            }
            else
            {
                Logger.Logger.Instance.Debug(string.Format("Mainlogic: process data = {0}, result = {1}",
                                                           data.Transaction.EventHash, !data.Transaction.IsError));

                if (data.Transaction.OperationName != OperationName.Read)
                {
                    _cache.Update(data.Transaction.CacheKey, data.Transaction);
                }

                if (data.Transaction.OperationType == OperationType.Sync)
                {
                    ProcessSyncTransaction(data.Transaction);
                }


                data.Transaction.PerfTimer.Complete();

                PerfCounters.DistributorCounters.Instance.ProcessPerSec.OperationFinished();
                PerfCounters.DistributorCounters.Instance.TransactionFailCount.Increment();
            }
        }