WSHCommon/Common/CommonNetwork_ICE/Connector/IceClientConnector.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using CommonNetwork_ICE.Common;
using Slice;
using CommonNetwork_ICE.Util;
using CommonNetwork_ICE.handler;
using CommonLang.Protocol;
using CommonNetwork_ICE.Msg;
using CommonNetwork_ICE.Session;
using CommonLang.Log;
using CommonLang.Concurrent;

namespace CommonNetwork_ICE.Client
{
    /// <summary>
    /// ICE客户端连接器,指定解码器,初始化本对象后可向指定服务器发送ICE消息，接收消息请先绑定会话侦听对象
    /// </summary>
    public abstract class IceClientConnector
    {
        private static Logger log = LoggerFactory.GetLogger("IceClientConnector");
        // 数据包编码解码器
        internal IceMessageCodec codec;
        // ICE接收消息委托处理类
        internal SenderDisp_ clientSendHandler;
        // 消息队列
        internal ClientMessageQueue messageQueue;
        // 会话对象
        internal IceClientNetSession session;
        // 会话消息序列号编号器
        private AtomicInteger msgSerialGenerator;

        public IceClientConnector(IceClientNetSession session)
            : this(session, Env.ICE_SEND_REMOTE_IP.Clone().ToString(), Env.ICE_SEND_REMOTE_PORT)
        {
        }

        public IceClientConnector(IceClientNetSession session, String ip, int port)
        {
            String localIp = "127.0.0.1";
            int localPort = 0;
            IceConnector netConnector = new IceConnector(
                Constants.SEND_INTERFACE_NAME,
                Constants.SERVER_SENDER_RECV_ADAPTER, 
                ip, port,
                localIp,
                localPort);
            this.Connector = netConnector;
            this.session = session;
            
            msgSerialGenerator = new AtomicInteger(1);
            RecvLastSerial = -1;
        }

        internal abstract SenderDisp_ getClientSendHandler(IceClientNetSession session, IceMessageCodec Codec);

        // ICE连接器
        internal IceConnector Connector { get; set; }
        // 是否已经连接上服务器
        public bool IsConnected { internal set; get; }
        // 客户端收到服务器发来的最后一条关键数据包序号
        internal long RecvLastSerial { set; get; }

        /// <summary>
        /// 初始化ICE接收和发送端
        /// </summary>
        public abstract void Open(int localListenPort);

        /// <summary>
        /// 设定本地监听端口
        /// </summary>
        /// <param name="localListenPort">初始监听端口</param>
        protected void setLocalPort(int localListenPort)
        {
            int port = NetUtil.GetUsablePort(localListenPort);
            if (port == -1)
            {
                Env.ENV_ERR_CODE = Error.ERR_CODE_3;
                throw new Exception("没有找到可用端口, 基准端口:" + this.Connector.GetConnectorConfig().LocalPort);
            }
            this.Connector.GetConnectorConfig().LocalPort = port;
        }

        internal void ConnectToSever(int commType)
        {
            // 客户端接收数据处理器
            clientSendHandler = getClientSendHandler(session, codec);
            try
            {
                bool initServerSuccessed = Connector.InitRecvServer(commType, clientSendHandler);
                if (!initServerSuccessed)
                {
                    throw new Exception("初始化服务器失败!");
                }
                Connector.InitSender(commType);
                Connector.Sender.Connect(this.Connector.GetConnectorConfig().LocalPort);
            }
            catch (Exception e)
            {
                log.Error("连接远程服务器IP【" + this.Connector.GetConnectorConfig().RemoteIp + "】和端口【" + this.Connector.GetConnectorConfig().RemotePort + "】异常：" + e.Message);
                throw e;
            }
            log.Log("正在连接服务器，请等待" + Env.CLIENT_CONNECT_WAIT_TIME / 100 + "秒。");
            int i = 0;
            while (i <= Env.CLIENT_CONNECT_WAIT_TIME)
            {
                if (IsConnected)
                {
                    break;
                }
                try
                {
                    Thread.Sleep(10);
                }
                catch (Exception e) { }
                i++;
            }
            if (IsConnected)
            {
                log.Info("已经连接上服务器IP【" + this.Connector.GetConnectorConfig().RemoteIp + "】和端口【" + this.Connector.GetConnectorConfig().RemotePort + "】,可以正常发送数据。");
            }
            else
            {
                throw new Exception("不能连接服务器，请检查远程IP【" + this.Connector.GetConnectorConfig().RemoteIp + "】和端口【" + this.Connector.GetConnectorConfig().RemotePort + "】。");
            }
        }

        /// <summary>
        /// 关闭通讯通道
        /// </summary>
        public abstract void Close();

        /// <summary>
        /// 关闭ICE网络资源
        /// </summary>
        internal void CloseConnect()
        {
            if (Connector != null)
            {
                if (Connector.Sender != null)
                {
                    bool error = false;
                    try
                    {
                        Connector.Sender.Close(this.Connector.GetConnectorConfig().LocalPort);
                    }
                    catch (Exception e)
                    {
                        error = true;
                        log.Error("关闭客户端出错:" + e.Message);
                    }
                    if (!error)
                    {
                        log.Log("正在关闭客户端，请等待" + Env.CLIENT_CONNECT_WAIT_TIME / 100 + "秒。");
                        int i = 0;
                        while (i <= Env.CLIENT_CONNECT_WAIT_TIME)
                        {
                            if (!IsConnected)
                            {
                                break;
                            }
                            try
                            {
                                Thread.Sleep(10);
                            }
                            catch (Exception e) { }
                            i++;
                        }
                        if (IsConnected)
                        {
                            log.Error("关闭客户端超时，强行终止。");
                            IsConnected = false;
                        }
                        else
                        {
                            log.Log("关闭客户端成功。");
                        }
                    }
                }
                Connector.Destroy();
                Connector = null;
            }
        }

        /// <summary>
        /// 设定解码器
        /// </summary>
        /// <param name="codec"></param>
        public void SetMessageCodec(IceMessageCodec codec)
        {
            this.codec = codec;
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息对象</param>
        public bool SendMessage(IMessage message)
        {
            if (!IsConnected)
            {
                log.Error("没有连接上服务器，不能发送数据。");
                session.onException(new Exception("没有连接上服务器，不能发送数据。"));
                return false;
            }
            if (this.codec == null)
            {
                log.Error("没有绑定解码器，不能发送数据。");
                session.onException(new Exception("没有绑定解码器，不能发送数据。"));
                return false;
            }
            TransMessage transMessage = null;
            try
            {
                this.codec.doEncode(message, out transMessage);
            }
            catch (Exception e)
            {
                String msg = "消息解码异常:" + message.GetType() + "" + e.Message;
                log.Error(msg);
                session.onException(e);
                return false;
            }
            transMessage.serial = msgSerialGenerator.GetAndIncrement();
            if (transMessage != null)
            {
                bool successed = SendTo(transMessage);
                if (!successed)
                {
                    return false;
                }
            }
            session.onSent(message, transMessage.length);
            return true;
        }

        /// <summary>
        /// 具体的发送方法
        /// </summary>
        /// <param name="transMessage"></param>
        internal abstract bool SendTo(TransMessage transMessage);

        // 设定服务器收到已发送数据包序列号
        internal void SetSentLastSerial(long serial)
        {
            if (messageQueue != null)
            {
                messageQueue.LastSerial = serial;
            }
        }
    }
}