• 欢迎访问奇跡の海网站,本站不上传任何资源,所有资源均来自于网络,欢迎加入奇跡の海~!奇跡の海-WordPress QQ群
  • 本站下载资源为网络上收集整理而来,并且以计算机技术研究交流为目的,版权归原作者所有,仅供大家参考,学习,不存在任何商业目的与商业用途.
  • 本站系统镜像均来自于官方原版,ed2k可视为P2P下载链接。所有操作系统默认均为试用版,如有正版密钥可以有效激活,本站不提供任何激活和相关服务。

P2P直连?经服务器中转?

编程开发 奇跡の海 2年前 (2017-02-23) 281次浏览 已收录 0个评论 扫描二维码

当同一个系统的两个客户端A、B相互发送消息给对方时,如果它们之间存在P2P通道,那么消息传送的路径就有两种:直接经P2P通道传送、或者经服务器中转。如下图所示:

通常就一般应用而言,如果P2P通道能够成功创建(即所谓的打洞成功),A和B之间的所有消息将直接走P2P通道,这样可以有效节省服务器的带宽和降低服务器的负载。这种模型即是所谓的“P2P通道优先”模型,也是最简单的通道选择模型。

一.通道质量优先模型
然而,有些系统可能不能就如此简单的处理,最简单的例子,如果A和B之间传递的某些类型的消息必需让服务器监控到,那么,这样的消息就必需经过服务器中转。接下来,我们讨论一种较为复杂的情况。比如,在网络语音对话系统中,通道的质量直接决定着用户体验的好坏。我们希望,在这种系统中,语音数据需要始终经由两条通道中的那个质量较高的通道进行传送。这种策略就是所谓的“通道质量优先”模型。

“通道质量优先”模型理解起来很简单,但是在实际中实现时,却还是很有难度的。通常有两种实现方式:

(1)定时检测、比较通道延时,并自动切换通道。

(2)由上层应用决定何时切换通道。一般而言,是当应用发现当前使用的通道不满足要求时,就主动要求切换到另外一条通道。

二.模型实现
下面,我们就基于ESFramework提供的通信功能,来实现这两种方式。我们使用AgileP2PCustomizeOutter类来封装它,并可通过属性控制来启用哪种方式。

public class AgileP2PCustomizeOutter:IEngineActor
    {
        //字典。userID - 当前选择的通道(如果为true,表示P2P通道;否则是经服务器中转)?
        private ObjectManager<string, bool> channelStateManager = new ObjectManager<string, bool>(); 
       private ICustomizeOutter customizeOutter; //消息发送器
        private IP2PController p2PController;//P2P控制器
        private IBasicOutter basicOutter; //心跳发送器
        private AgileCycleEngine agileCycleEngine; //定时检测引擎

        #region PingTestSpanInSecs
        private int pingTestSpanInSecs = 60;
        /// <summary>
        /// 定时进行ping测试以及自动切换通道的时间间隔,单位:秒。默认值为60。
        /// 如果设置为小于等于0,则表示不进行定时ping测试,也不会自动切换通道。
        /// </summary>
        public int PingTestSpanInSecs
        {
            get { return pingTestSpanInSecs; }
            set { pingTestSpanInSecs = value; }
        }    
        #endregion   

        #region Initialize
        public void Initialize(ICustomizeOutter _customizeOutter, IP2PController _p2PController, IBasicOutter _basicOutter)
        {
            this.customizeOutter = _customizeOutter;
            this.p2PController = _p2PController;
            this.basicOutter = _basicOutter;

            this.p2PController.P2PChannelOpened += new ESBasic.CbGeneric<P2PChannelState>(p2PController_P2PChannelOpened);
            this.p2PController.P2PChannelClosed += new ESBasic.CbGeneric<P2PChannelState>(p2PController_P2PChannelClosed);
            this.p2PController.AllP2PChannelClosed += new ESBasic.CbGeneric(p2PController_AllP2PChannelClosed);
            Dictionary<string, P2PChannelState> dic = this.p2PController.GetP2PChannelState();
            foreach (P2PChannelState state in dic.Values)
            {
                bool p2pFaster = this.TestSpeed(state.DestUserID);
                this.channelStateManager.Add(state.DestUserID, p2pFaster);
            }

            if (this.pingTestSpanInSecs > 0)
            {
                this.agileCycleEngine = new AgileCycleEngine(this);
                this.agileCycleEngine.DetectSpanInSecs = this.pingTestSpanInSecs;
                this.agileCycleEngine.Start();
            }
        }

        //定时执行,当前客户端到其它客户端之间的通道选择
        public bool EngineAction()
        {
            foreach (string userID in this.channelStateManager.GetKeyList())
            {
                bool p2pFaster = this.TestSpeed(userID);
                this.channelStateManager.Add(userID, p2pFaster);
            }

            return true;
        }

        void p2PController_AllP2PChannelClosed()
        {
            this.channelStateManager.Clear();
        }

        void p2PController_P2PChannelClosed(P2PChannelState state)
        {
            this.channelStateManager.Remove(state.DestUserID);
        }

        void p2PController_P2PChannelOpened(P2PChannelState state)
        {
            bool p2pFaster = this.TestSpeed(state.DestUserID);
            this.channelStateManager.Add(state.DestUserID, p2pFaster);
        }
        #endregion

        #region TestSpeed
        /// <summary>
        /// 定时测试
        /// </summary>     
        private bool TestSpeed(string userID)
        {
            try
            {
                int transfer = this.basicOutter.PingByServer(userID);
                int p2p = this.basicOutter.PingByP2PChannel(userID);
                return p2p <= transfer;
            }
            catch (Exception ee)
            {
                return false;
            }
        }
        #endregion

        /// <summary>
        /// 手动切换通道。
        /// </summary>        
        public void SwitchChannel(string destUserID)
        {
            if (this.channelStateManager.Contains(destUserID))
            {
                bool p2p = this.channelStateManager.Get(destUserID);
                this.channelStateManager.Add(destUserID, !p2p);
            }
        }

        /// <summary>
        /// 到目标用户是否使用的是P2P通道。
        /// </summary>        
        public bool IsUsingP2PChannel(string destUserID)
        {
            return this.channelStateManager.Get(destUserID);
        }

        public bool IsExistP2PChannel(string destUserID)
        {
            return this.channelStateManager.Contains(destUserID);
        }

        /// <summary>
        /// 向在线用户发送信息。
        /// </summary>
        /// <param name="targetUserID">接收消息的目标用户ID。</param>
        /// <param name="informationType">自定义信息类型</param>
        /// <param name="post">是否采用Post模式发送消息</param>  
        /// <param name="action">当通道繁忙时所采取的动作</param>  
        public void Send(string targetUserID, int informationType, byte[] info, bool post, ActionTypeOnChannelIsBusy action)
        {
            bool p2pFaster = this.channelStateManager.Get(targetUserID);
            ChannelMode mode = p2pFaster ? ChannelMode.ByP2PChannel : ChannelMode.TransferByServer;
            this.customizeOutter.Send(targetUserID, informationType, info, post, action, mode);
        }

        /// <summary>
        /// 向在线用户或服务器发送大的数据块信息。直到数据发送完毕,该方法才会返回。如果担心长时间阻塞调用线程,可考虑异步调用本方法。
        /// </summary>
        /// <param name="targetUserID">接收消息的目标用户ID。如果为null,表示接收者为服务器。</param>
        /// <param name="informationType">自定义信息类型</param>
        /// <param name="blobInfo">大的数据块信息</param>  
        /// <param name="fragmentSize">分片传递时,片段的大小</param>  
        public void SendBlob(string targetUserID, int informationType, byte[] blobInfo, int fragmentSize)
        {
            bool p2pFaster = this.channelStateManager.Get(targetUserID);
            ChannelMode mode = p2pFaster ? ChannelMode.ByP2PChannel : ChannelMode.TransferByServer;
            this.customizeOutter.SendBlob(targetUserID, informationType, blobInfo, fragmentSize, mode);
        }       
    }

现在,我们对上面的实现简单解释一下。

(1)由于当前客户端可能会与多个其它的客户端进行通信,而与每一个其它的客户端之间的通信都有通道选择的问题,所以需要一个字典ObjectManager将它们管理起来。

(2)当某个P2P通道创建成功时,将进行首次ping比较,并将结果记录到字典中。

(3)定时引擎每隔60秒,分别针对每个其它客户端进行通道检测比较,自动选择ping值小的那个通道。

(4)当我们将PingTestSpanInSecs设为0时,就可以使用SwitchChannel方法来手动切换通道,即实现了上述的方式2。

(5)我们最终的目的是实现Send方法和SendBlob方法,之后,就可以使用AgileP2PCustomizeOutter类来替换ICustomizeOutter发送消息。

三.方式选择
上面讲到“通道质量优先”模型的两种实现方式,那么在实际的应用中,如何进行选择了?

1.ping检测比较,自动切换

就这种方式而言,其缺陷在于,在客户端之间需要进行高频通信的系统中,ping检测可能是非常不准确的,甚至是错误的。

比如,在实时视频对话系统中,其对带宽的要求是比较高的,假设,现在所有的视频数据走的都是P2P通道,那么P2P通道就非常忙碌,而经服务器中转的通道几乎就是空闲的。所以,当下一次定时ping检测到来时,P2P通道的ping值就会比实际的大。从而导致判断失误,而发生错误的自动切换。

2.手动切换

对于刚才视频对话的例子,使用手动切换可能是更好的选择,由应用根据上层的实际效果来决定是否需要切换通道。比如,还以视频对话系统为例,应用可以根据信息接收方的定时反馈(在一段时间内,缺少音/视频包的个数,音/视频包的总延时等统计信息)来决定是否要切换到另外一个通道。这种方式更简洁描述可以表达为:如果当前通道质量已达到应用需求,即使另一个通道更快更稳定,也不进行切换;如果当前通道质量达不到应用需求,则切换到另一个通道(有可能另一个通道的质量更糟糕)。

本文只是简单地引出通道选择模型的问题,实际上,这个问题是相当复杂的,特别是在一些通信要求很高的项目中,而且,如果将广播消息的通道模型考虑进来就更麻烦了,有兴趣的朋友可以留言进行更深入的讨论。


版权声明:本站所有文章和资源使用CC BY-NC-SA 4.0协议授权发布 , 转载应当以相同方式注明文章来自“SeaOMC.COM->P2P直连?经服务器中转?!在下边可以分享本文哦!
喜欢 (0)
[]
分享 (0)
奇跡の海
关于作者:
一个WordPress菜鸟!
发表我的评论
取消评论

表情 贴图 加粗 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址