Ejemplo n.º 1
0
        /// <summary>
        /// 注册一个ICommandHandler
        /// </summary>
        /// <param name="type">支持的命令类型</param>
        /// <param name="handler"></param>
        ///
        public void registerReportHandler(Constants.TK_CommandType type, ICommandHandler handler, Dictionary <Constants.TK_CommandType, byte> supercommands)
        {
            try
            {
                m_RWHandlers.AcquireWriterLock(-1);

                if (!this.m_CommandSender.ContainsKey(handler))
                {
                    this.m_CommandSender.Add(handler, 1);
                }

                List <ICommandHandler> handlers;
                if (this.m_ReportHandlers.ContainsKey(type))
                {
                    handlers = this.m_ReportHandlers[type];
                }
                else
                {
                    handlers = (this.m_ReportHandlers[type] = new List <ICommandHandler>());
                }

                handlers.Add(handler);

                // 为每一个命令句柄构建一个派发实例
                // 一个句柄可能侦听多种命令类型,派发实例是唯一的,只是在RefCount上累加
                // 这样可以做到每个命令句柄在多线程环境下独立处理命令,互不影响
                if (!m_Dispatcher.ContainsKey(handler))
                {
                    CommandDispatcher dispatcher = new CommandDispatcher(handler, supercommands);
                    dispatcher.TypeCount  = 1;
                    m_Dispatcher[handler] = dispatcher;

                    dispatcher.StartWork();
                }
                else
                {
                    CommandDispatcher dispatcher = (CommandDispatcher)m_Dispatcher[handler];
                    ++dispatcher.TypeCount;
                }
            }
            catch (Exception ex)
            {
                string s = ex.ToString();
            }
            finally
            {
                m_RWHandlers.ReleaseWriterLock();
            }
        }
Ejemplo n.º 2
0
        public void unregisterReportHandler(Constants.TK_CommandType type, ICommandHandler handler)
        {
            try
            {
                m_RWHandlers.AcquireWriterLock(-1);

                if (!this.m_ReportHandlers.ContainsKey(type))
                {
                    return; // 无此类型处理器注册,直接返回
                }
                List <ICommandHandler> handlers = this.m_ReportHandlers[type];
                handlers.Remove(handler);

                // 在注销派发实例时,必须在RefCount为零的情况下,才可以彻底删除
                if (m_Dispatcher.ContainsKey(handler))
                {
                    CommandDispatcher dispatcher = (CommandDispatcher)m_Dispatcher[handler];
                    --dispatcher.TypeCount;

                    if (dispatcher.TypeCount == 0)
                    {
                        dispatcher.EndWork();
                        m_Dispatcher.Remove(handler);

                        m_CommandSender.Remove(handler);
                    }
                }
            }
            catch
            {
            }
            finally
            {
                m_RWHandlers.ReleaseWriterLock();
            }
        }
Ejemplo n.º 3
0
        virtual public bool decode(string msg)
        {
            string s = msg.Substring(Constants.MSG_START_ID.Length, msg.Length - Constants.MSG_START_ID.Length - Constants.MSG_END_ID.Length);

            s = msg.Replace(Constants.MSG_DOUBLE_START_ID, Constants.MSG_START_ID);
            s = s.Replace(Constants.MSG_DOUBLE_END_ID, Constants.MSG_END_ID);

            bool cont = true;

            lock (m_SyncRoot)
            {
                m_Content.Clear();
                while (cont)
                {
                    string ln;

                    int i = 0;

                    int startpos = 0;
                    while (true)
                    {
                        i = s.IndexOf(Constants.MSG_LINE_TERMINATOR, startpos);
                        if (i == -1)
                        {
                            break;
                        }

                        if (s.Length - i < Constants.MSG_DOUBLE_LINE_TERMINATOR.Length)
                        {
                            break;
                        }

                        // 如果是双行结束符,表明是做过转义
                        if (s.Substring(i + Constants.MSG_LINE_TERMINATOR.Length, Constants.MSG_LINE_TERMINATOR.Length) == Constants.MSG_LINE_TERMINATOR)
                        {
                            startpos = i + Constants.MSG_DOUBLE_LINE_TERMINATOR.Length;
                        }
                        else
                        {
                            break;
                        }
                    }

                    if (i == -1)
                    {
                        ln   = s;
                        cont = false;
                        break;
                    }
                    else
                    {
                        ln = s.Substring(0, i);
                        s  = s.Substring(i + Constants.MSG_LINE_TERMINATOR.Length);
                    }

                    int index = ln.IndexOf(Constants.MSG_NV_TERMINATOR);
                    //				if (index == -1)
                    //					return false; // 每一行都必须由 name = value的形式构成,找不到分隔符则中断解析
                    if (index == -1)
                    {
                        continue;               //解析失败,继续解析下一行
                    }
                    string        name = ln.Substring(0, index).Trim();
                    StringBuilder val  = new StringBuilder(ln.Substring(index + Constants.MSG_NV_TERMINATOR.Length));
                    //string val = ln.Substring(index + Constants.MSG_NV_TERMINATOR.Length);
                    m_Content[name] = val.Replace(Constants.MSG_DOUBLE_LINE_TERMINATOR, Constants.MSG_LINE_TERMINATOR);

                    if (name == Constants.MSG_PARANAME_COMMAND)
                    {
                        string value = val.ToString();
                        switch (value)
                        {
                        case Constants.MSG_TYPE_LOGIN:
                            this.m_Type = Constants.TK_CommandType.LOGIN;
                            break;

                        case Constants.MSG_TYPE_LOGOUT:
                            this.m_Type = Constants.TK_CommandType.LOGOUT;
                            break;

                        case Constants.MSG_TYPE_PROJECT_ADD:
                            this.m_Type = Constants.TK_CommandType.PROJECT_ADD;
                            break;

                        case Constants.MSG_TYPE_PROJECT_MODIFY:
                            this.m_Type = Constants.TK_CommandType.PROJECT_MODIFY;
                            break;

                        case Constants.MSG_TYPE_PROJECT_REMOVE:
                            this.m_Type = Constants.TK_CommandType.PROJECT_REMOVE;
                            break;

                        case Constants.MSG_TYPE_ALARM_REPORT:
                            this.m_Type = Constants.TK_CommandType.ALARM_REPORT;
                            break;

                        case Constants.MSG_TYPE_RESPONSE:
                            this.m_Type = Constants.TK_CommandType.RESPONSE;
                            break;

                        case Constants.MSG_TYPE_KEEPALIVE:
                            this.m_Type = Constants.TK_CommandType.KEEPALIVE;
                            break;

                        case Constants.MSG_TYPE_ALARM_ACK:
                            this.m_Type = Constants.TK_CommandType.ALARM_ACK;
                            break;

                        case Constants.MSG_TYPE_ALARM_REACK:
                            this.m_Type = Constants.TK_CommandType.ALARM_REACK;
                            break;

                        case Constants.MSG_TYPE_SENDORDER:
                            this.m_Type = Constants.TK_CommandType.SENDORDER;
                            break;

                        case Constants.MSG_TYPE_ALARM_ACK_CHANGE:
                            m_Type = Constants.TK_CommandType.ALARM_ACK_CHANGE;
                            break;

                        case Constants.MSG_TYPE_ALARM_ORDER_CHANGE:
                            m_Type = Constants.TK_CommandType.ALARM_ORDER_CHANGE;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_LOGIN:
                            m_Type = Constants.TK_CommandType.ADAPTER_LOGIN;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_LOGOUT:
                            m_Type = Constants.TK_CommandType.ADAPTER_LOGOUT;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_STATE_REPORT:
                            m_Type = Constants.TK_CommandType.ADAPTER_STATE_REPORT;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_ALARM_REPORT:
                            m_Type = Constants.TK_CommandType.ADAPTER_ALARM_REPORT;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_START:
                            m_Type = Constants.TK_CommandType.ADAPTER_START;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_STOP:
                            m_Type = Constants.TK_CommandType.ADAPTER_STOP;
                            break;

                        case Constants.MSG_TYPE_ALLOCATE_TKSN:
                            m_Type = Constants.TK_CommandType.ALLOCATE_TKSN;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_GETCURLOG:
                            m_Type = Constants.TK_CommandType.ADAPTER_GETCURLOG;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_GETLOGFILES:
                            m_Type = Constants.TK_CommandType.ADAPTER_GETLOGFILES;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_GETOMCLIST:
                            m_Type = Constants.TK_CommandType.ADAPTER_GETOMCLIST;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_GETRUNTIMEINFO:
                            m_Type = Constants.TK_CommandType.ADAPTER_GETRUNTIMEINFO;
                            break;

                        case Constants.MSG_TYPE_ADAPTER_SHUTDOWN:
                            m_Type = Constants.TK_CommandType.ADAPTER_SHUTDOWN;
                            break;

                        case Constants.MSG_TYPE_SERVER_GETCURLOG:
                            m_Type = Constants.TK_CommandType.SERVER_GETCURLOG;
                            break;

                        case Constants.MSG_TYPE_SERVER_GETLOGFILES:
                            m_Type = Constants.TK_CommandType.SERVER_GETLOGFILES;
                            break;

                        case Constants.MSG_TYPE_SERVER_GETRUNTIMEINFO:
                            m_Type = Constants.TK_CommandType.SERVER_GETRUNTIMEINFO;
                            break;

                        case Constants.MSG_TYPE_ALARM_PROJECT_CHANGE:
                            m_Type = Constants.TK_CommandType.ALARM_PROJECT_CHANGE;
                            break;

                        case Constants.MSG_TYPE_ALARM_HANG_UP:                //告警挂起
                            m_Type = Constants.TK_CommandType.ALARM_HANG_UP;
                            break;

                        case Constants.MSG_TYPE_ALARM_HANG_DOWN:
                            m_Type = Constants.TK_CommandType.ALARM_HANG_DOWN;
                            break;

                        case Constants.MSG_TYPE_ALARM_HANG_CHANGE:
                            m_Type = Constants.TK_CommandType.ALARM_HANG_CHANGE;
                            break;

                        default:
                            throw new Exception("解包时遇到未知的命令类型:" + value);
                        }
                        //this.m_Type = (Constants.TK_CommandType)(Int32.Parse(val));
                    }
                    else if (name == Constants.MSG_PARANAME_SEQUENCE_ID)
                    {
                        m_SeqID = Int64.Parse(val.ToString());
                    }
                } //  end while
            }

            return(true);
        }