public async Task <TValue> GetOrAddAsync(ITransaction tx, TKey key, Func <TKey, TValue> valueFactory)
        {
            if (reliableDictionary == null)
            {
                await InitializeReliableDictionary();
            }

            return(await reliableDictionary.GetOrAddAsync(tx, key, valueFactory));
        }
        private async Task ProcessOrdersAsync(
            Order order,
            IReliableDictionary <OrderQueueKey, OrderQueue> storage,
            OrderQueueKey orderQueueKey,
            OrderQueueKey oppositeOrderQueueKey)
        {
            using (var tx = _stateManager.CreateTransaction())
            {
                var orderQueue = await storage.GetOrAddAsync(
                    tx,
                    orderQueueKey,
                    new OrderQueue(order.CurrencyPair, order.Side));

                var oppositeOrderQueue = await storage.GetOrAddAsync(
                    tx,
                    oppositeOrderQueueKey,
                    new OrderQueue(order.CurrencyPair, order.Side == Side.Buy ? Side.Sell : Side.Buy));

                while (true)
                {
                    var oppositeOrder = oppositeOrderQueue.Peek();
                    if (oppositeOrder == null)
                    {
                        break;
                    }

                    var matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);

                    if (matched)
                    {
                        matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);
                        if (matched)
                        {
                            ProcessOrders(order, orderQueue, oppositeOrder, oppositeOrderQueue);
                        }
                        else
                        {
                            // process further if some thread is here
                            continue;
                        }
                    }

                    if (order.IsClosed || !matched || oppositeOrderQueue.IsEmpty)
                    {
                        break;
                    }
                }

                await storage.AddOrUpdateAsync(tx, orderQueueKey, orderQueue, (key, old) => orderQueue);

                await storage.AddOrUpdateAsync(tx, oppositeOrderQueueKey, oppositeOrderQueue, (key, old) => orderQueue);

                await tx.CommitAsync();
            }
        }
示例#3
0
        public async Task ProcessDependencyUpdateErrorsAsync()
        {
            if (_options.IsEnabled)
            {
                IReliableDictionary <string, DateTimeOffset> checkpointEvaluator =
                    await _stateManager.GetOrAddAsync <IReliableDictionary <string, DateTimeOffset> >("checkpointEvaluator");

                try
                {
                    DateTimeOffset checkpoint;
                    using (ITransaction tx = _stateManager.CreateTransaction())
                    {
                        checkpoint = await checkpointEvaluator.GetOrAddAsync(
                            tx,
                            "checkpointEvaluator",
                            DateTimeOffset.UtcNow
                            );

                        await tx.CommitAsync();
                    }
                    await CheckForErrorsInUpdateHistoryTablesAsync(
                        checkpoint,
                        _options.GithubUrl,
                        checkpointEvaluator);
                }
                catch (TimeoutException exe)
                {
                    _logger.LogError(exe, "Unable to connect to reliable services.");
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Unable to create a github issue.");
                }
            }
        }
示例#4
0
        /// <summary>
        /// Write all messages contained in a single transaction to the underlying reliable dictionary
        /// </summary>
        /// <param name="messages">list of messages</param>
        /// <returns></returns>
        protected async override Task <IImmutableList <Exception> > WriteMessagesAsync(IEnumerable <AtomicWrite> messages)
        {
            IReliableDictionary <string, LinkedList <IPersistentRepresentation> > messagelist = null;

            using (var tx = this.StateManager.CreateTransaction())
            {
                foreach (var message in messages)
                {
                    foreach (var payload in (IEnumerable <IPersistentRepresentation>)message.Payload)
                    {
                        if (messagelist == null)
                        {
                            messagelist = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, LinkedList <IPersistentRepresentation> > >($"Messages_{payload.PersistenceId}");
                        }

                        var list = await messagelist.GetOrAddAsync(tx, payload.PersistenceId, pid => new LinkedList <IPersistentRepresentation>());

                        list.AddLast(payload);
                    }
                }

                await tx.CommitAsync();
            }

            return((IImmutableList <Exception>)null); // all good
        }
示例#5
0
        public async Task AddProduct(Product product)
        {
            IReliableDictionary <Guid, Product> products = await _stateManager
                                                           .GetOrAddAsync <IReliableDictionary <Guid, Product> >("products");

            using (ITransaction tx = _stateManager.CreateTransaction())
            {
                await products.GetOrAddAsync(tx, product.Id, product);

                await tx.CommitAsync();
            }
        }
        private async Task AddOrderAsync(Order order, IReliableDictionary <OrderQueueKey, OrderQueue> storage, OrderQueueKey orderQueueKey)
        {
            using (var tx = _stateManager.CreateTransaction())
            {
                var orderQueue = await storage.GetOrAddAsync(
                    tx,
                    orderQueueKey,
                    new OrderQueue(order.CurrencyPair, order.Side));

                orderQueue.Add(order);

                await storage.AddOrUpdateAsync(tx, orderQueueKey, orderQueue, (key, old) => orderQueue);

                await tx.CommitAsync();
            }
        }
 public Task <TValue> GetOrAdd(Core.ITransaction tx, TKey key, Func <TKey, TValue> addValueFactory)
 {
     return(wrappedReliableDictionary.GetOrAddAsync(((ServiceFabTransaction)tx).WrappedTransaction, key, key1 => addValueFactory.Invoke(key)));
 }
        public async Task AddMessageAsync(Message message)
        {
            DateTime time = DateTime.Now.ToLocalTime();

            IReliableDictionary <DateTime, Message> messagesDictionary =
                await this.StateManager.GetOrAddAsync <IReliableDictionary <DateTime, Message> >("messages");

            //dictionary for the scores
            IReliableDictionary <string, int> scoresDictionary =
                await StateManager.GetOrAddAsync <IReliableDictionary <string, int> >("scores");

            var currentQuestion =
                await StateManager.GetOrAddAsync <IReliableQueue <KeyValuePair <string, string> > >("currentQuestion");

            using (ITransaction tx = StateManager.CreateTransaction())
            {
                var currentScoreConditional = await scoresDictionary.TryGetValueAsync(tx, message.Name);

                if (!currentScoreConditional.HasValue)
                {
                    await scoresDictionary.GetOrAddAsync(tx, message.Name, 0);
                }
                await tx.CommitAsync();
            }

            //checking for the right answer
            using (ITransaction tx = this.StateManager.CreateTransaction())
            {
                if (message.MessageText.ToLowerInvariant().Trim() == "try me")
                {
                    var q = TriviaDatabase.GetRandomQuestion();
                    await currentQuestion.TryDequeueAsync(tx);

                    await currentQuestion.EnqueueAsync(tx, q);

                    await tx.CommitAsync();
                }
                else
                {
                    var question = await currentQuestion.TryPeekAsync(tx);

                    if (question.Value.Value.ToLowerInvariant().Trim()
                        == message.MessageText.ToLowerInvariant().Trim())
                    {
                        await messagesDictionary.AddAsync(tx, time,
                                                          new Message { Name = message.Name, MessageText = message.MessageText });

                        await messagesDictionary.AddAsync(tx, time.AddTicks(1),
                                                          new Message { Name = "Admin", MessageText = "You are correct " + message.Name + "! You get one point for this" });

                        //get and update the score
                        var currentScoreConditional = await scoresDictionary.TryGetValueAsync(tx, message.Name);

                        var currentScore = currentScoreConditional.HasValue ? currentScoreConditional.Value + 1 : 0;
                        await scoresDictionary.AddOrUpdateAsync(tx, message.Name, currentScore, (x, y) => ++ y);

                        await currentQuestion.TryDequeueAsync(tx);

                        await currentQuestion.EnqueueAsync(tx, TriviaDatabase.GetRandomQuestion());

                        await tx.CommitAsync();
                    }
                    else
                    {
                        await messagesDictionary.AddAsync(tx, time, message);

                        await tx.CommitAsync();
                    }
                }
            }
        }