Esempio n. 1
0
        internal TransStream ExecRequset(IQueueMessage request)
        {
            bool responseAck = false;

            try
            {
                if (request.QCommand == QueueCmd.QueueHasValue)
                {
                    return(MessageAckServer.DoReportValue(QueueCount(request.Host)));
                }

                Logger.Debug("QueueController ExecRequset : {0}", request.Print());

                switch (request.QCommand)
                {
                case QueueCmd.Enqueue:
                    responseAck = true;
                    //MQueue Q = Get(request.Host);
                    var ack = ExecSet((QueueItem)request);
                    return(MessageAckServer.DoResponse(ack));

                case QueueCmd.Dequeue:
                case QueueCmd.DequeuePriority:
                case QueueCmd.DequeueItem:
                case QueueCmd.Peek:
                case QueueCmd.PeekPriority:
                case QueueCmd.PeekItem:
                    return(MessageAckServer.DoResponse(ExecGet(request), MessageState.Receiving));

                case QueueCmd.Commit:
                    break;

                case QueueCmd.Abort:
                    break;

                //operation
                case QueueCmd.AddQueue:
                    responseAck = true;
                    MQueue mq = null;
                    return(MessageAckServer.DoResponse(AddQueue(new QProperties(request.BodyStream), out mq)));

                case QueueCmd.RemoveQueue:
                    responseAck = true;
                    return(MessageAckServer.DoResponse(RemoveQueue(request.Host)));

                case QueueCmd.HoldEnqueue:
                    throw new Exception("Operation not supported");

                case QueueCmd.NoneHoldEnqueue:
                    throw new Exception("Operation not supported");

                case QueueCmd.HoldDequeue:
                    throw new Exception("Operation not supported");

                case QueueCmd.NoneHoldDequeue:
                    throw new Exception("Operation not supported");

                case QueueCmd.EnableQueue:
                    throw new Exception("Operation not supported");

                case QueueCmd.DisableQueue:
                    throw new Exception("Operation not supported");

                case QueueCmd.ClearQueue:
                    throw new Exception("Operation not supported");

                //reports
                case QueueCmd.Exists:
                    responseAck = true;
                    return(MessageAckServer.DoResponse(Exists(request.Host)));

                case QueueCmd.ReportQueueList:
                    var list = GetQueueList();
                    return(new TransStream(list));

                case QueueCmd.QueueProperty:
                case QueueCmd.ReportQueueItems:
                    return(ExecQuery(request));

                case QueueCmd.ReportQueueStatistic:
                    return(GetQueueReport(request));

                //throw new Exception("Operation not supported");
                case QueueCmd.PerformanceCounter:
                    throw new Exception("Operation not supported");

                case QueueCmd.QueueCount:
                    return(MessageAckServer.DoReport(QueueCount(request.Host), QueueCmd.QueueCount, MessageState.Ok, null));
                }
            }
            catch (MessageException mex)
            {
                Logger.Exception("ExecGet MessageException: ", mex, true);
                return(MessageAckServer.DoError(mex.MessageState, request, responseAck, mex));
            }
            catch (ArgumentException ase)
            {
                Logger.Exception("ExecGet ArgumentException: ", ase, true, true);
                return(MessageAckServer.DoError(MessageState.ArgumentsError, request, responseAck, ase));
            }
            catch (SerializationException se)
            {
                Logger.Exception("ExecGet SerializationException: ", se, true);
                return(MessageAckServer.DoError(MessageState.SerializeError, request, responseAck, se));
            }
            catch (Exception ex)
            {
                Logger.Exception("ExecGet Exception: ", ex, true, true);
                return(MessageAckServer.DoError(MessageState.UnExpectedError, request, responseAck, ex));
            }
            return(null);
        }