示例#1
0
 private void AddMsmqQueue(Dictionary<string, object> serverConnection, Model.Queue queue) {
   try {
     _monitorQueues.Add(new MsmqMessageQueue(serverConnection[CS_SERVER] as string, queue));
   } catch( Exception e ) {
     OnError("Error occured when loading queue: '{0}\\{1}'\n\r".With(serverConnection.AsString(), queue.Name), e, false);
   }
 }
示例#2
0
        private QueueItem CreateQueueItem(Model.Queue queue, Message msg)
        {
            var itm = new QueueItem(queue);

            itm.DisplayName = msg.Label;
            itm.Id          = msg.Id;
            itm.ArrivedTime = msg.ArrivedTime;
            //itm.Content = ReadMessageStream(msg.BodyStream);

            itm.Headers = new Dictionary <string, string>();
            if (msg.Extension.Length > 0)
            {
                var stream = new MemoryStream(msg.Extension);
                var o      = headerSerializer.Deserialize(stream);

                foreach (var pair in o as List <HeaderInfo> )
                {
                    if (pair.Key != null)
                    {
                        itm.Headers.Add(pair.Key, pair.Value);
                    }
                }
            }


            return(itm);
        }
 private void AddAzureQueue(string _connectionStr, Model.Queue queue)
 {
     try {
         //var mgr = NamespaceManager.CreateFromConnectionString(_serverName);
         //var client = QueueClient.CreateFromConnectionString(_serverName, queue);
         _monitorQueues.Add(new AzureMessageQueue(_connectionStr, queue));
     } catch (Exception e) {
         OnError("Error occured when loading queue: '{0}\\{1}'\n\r".With(_connectionStr, queue.Name), e, false);
     }
 }
示例#4
0
    private bool TryAddItem(Message msg, Model.Queue q) {

      lock( _peekItemsLock ) {

        if( !_peekedItems.Any(i => i.Id == msg.Id) ) {

          var itm = CreateQueueItem(q, msg);

          if( PrepareQueueItemForAdd(itm) )
            _peekedItems.Add(itm);


          return true;

        } else return false;
      }

    }
示例#5
0
        /// <summary>Удаляет заданный элемент из очереди</summary>
        /// <param name="id">Номер парковочной карты</param>
        /// <param name="reason">Причина исключения из очереди</param>
        public Model.IQueueHistory Delete(string id, OutputReasonEnum reason)
        {
            try
            {
                // для удаления элемента необходима полная информация о нём:
                var entity = new Model.Queue().Get(id);

                if (QueueManager.DeQueueTran(entity, reason))
                {
                    // возврат информации об удалённом элементе
                    return new QueueHistory()
                    {
                        Input = entity.Input,
                        ParkingCard = entity.ParkingCard
                    }.Get();
                }
                return null;
            }
            catch (Exception e)
            {
                Model.Log.Put(message: e.Message, exception: e);
                return null;
            }
        }
示例#6
0
        /// <summary>
        /// Логика ротации (состояние: количество ротаций и фиксированная позиция).
        /// Данное состояние хранится в БД.
        /// </summary>
        internal static bool RotateTran(bool once = false)
        {
            lock (Locker)
            {
                // остановка таймера:
                ResetTimer(started: false);

                using (Repository repository = new Repository())
                {
                    using (var tran = repository.Database.BeginTransaction(TranIsolationLevel))
                    {
                        // проверка наличия элементов в текущей транзакции:
                        if (!repository.Queue.Any())
                        {
                            return(false);
                        }

                        // извлечение первого элемента:
                        // ToDo: не в рамках текущей транзакции!!!
                        var id          = new Model.Queue().Get(1).First().ParkingCard;
                        var firstEntity = repository.Queue.First(t => t.ParkingCard == id);

                        // увеличение счётчика ротаций:
                        firstEntity.Rotation =
                            (byte?)(firstEntity.Rotation.HasValue
                                ? firstEntity.Rotation + 1
                                : 1);

                        // отметка времени первой ротации:
                        if (firstEntity.RotationStart == null)
                        {
                            firstEntity.RotationStart = DateTime.Now;
                        }

                        repository.SaveChanges();

                        // пересчёт фиксированных позиций:
                        FixedPositionsMoveUp(repository);

                        // присвоение принудительной позиции:
                        firstEntity.Position = RotationPlaceParam;
                        repository.SaveChanges();

                        if (firstEntity.Rotation >= RotationCountLimitParam)
                        {
                            DeQueueTran(firstEntity, OutputReasonEnum.Rotation, repository, tran);
                        }
                        else
                        {
                            tran.Commit();

                            Model.Notifier.OnQueueChanged(new QueueChangedEventArgs()
                            {
                                Reason = QueueChangedEnum.Rotation,
                                Queue  = new Model.Queue().Get(ViewLimitParam)
                            });
                        }
                    }
                }

                // запуск таймера:
                if (!once)
                {
                    ResetTimer(started: true);
                }

                return(true);
            }
        }
        private void MapQueues(IEnumerable<Queue> queues, List<Model.Queue> model)
        {
            foreach (var sourceQueue in queues)
            {
                var destQueue = new Model.Queue
                {
                    Name = sourceQueue.name,
                    Durable = sourceQueue.durable
                };

                if (sourceQueue.Arguments != null)
                    MapArguments(sourceQueue.Arguments, destQueue.Arguments);

                if (sourceQueue.Bindings != null)
                    MapBindings(sourceQueue.Bindings, destQueue.Bindings);

                model.Add(destQueue);
            }
        }