第一章我们讲了程序的基本启动流程，这里面涉及到了各种节点信息，master，net，gate，game...，当然，无论他叫什么名字，归根结底他都是一个节点。就好比爷爷爸爸儿子，就像是父父节点，父节点，子节点，不管在家里地位如何，他终究是人。那么是如何实现这个分布式节点的呢，我们这章进入firefly源码内一探究竟
节点相关的文件都存放在distributed，也就是分布式模块当中
-
distributed模块说明
该模块主要封装了关于节点的所有方法以及类
-
distributed模块结构解析
ade7e1523ddb8050bee21f8f937a6727.jpg
PBRoot，root节点对象（所有拥有child节点的都是root节点，root节点本身可以有root节点，好比爷爷是root节点，爸爸是root节点，因为他们都有儿子，但是儿子就只能是child节点）
ChildsManager，子节点管理基类
Child 对象对应的是连接到本服务进程的某个服务进程对象。称为子节点对象
RemoteObject远程调用对象，所有child对象都是一个远程调用对象，远程调用对象封装了一个child对象和child对象的远程代理通道（用于反向调用），以及service对象（用于提供远程调用的方法，在下面你会看到很多他的身影，你可先不用管他是什么，只需要知道他能提供被调用的方法就可以了，因为在下一章，我们会详细描述service）
-
分布式模块的文件结构如下
模块结构如下：
文件结构：
-distributed
-__init__.py
-child.py
-manager.py
-node.py
-reference.py
-root.py
-
- _ init _.py
#该文件本身并没有什么意义，存在的作用是将distributed文件变成一个可以导入的包
-
-child.py
# 没有子节点的节点统称为child节点，这类节点一般用于提供各类服务
'''
Created on 2013-8-14
@author: lan (www.9miao.com)
'''
class Child(object):
'''子节点对象'''
def __init__(self,cid,name):
'''初始化子节点对象
'''
self._id = cid
self._name = name
self._transport = None
def getName(self):
'''获取子节点的名称'''
return self._name
def setTransport(self,transport):
'''设置子节点的通道'''
self._transport = transport
def callbackChild(self,*args,**kw):
'''回调子节点的接口
return a Defered Object (recvdata)
'''
recvdata = self._transport.callRemote('callChild',*args,**kw)
return recvdata
-
manager.py
# manager 顾名思义，是一个管理类
# 在分布式节点中，既然有子节点，那么就会有父节点。
# 而有了根节点，就需要赋予父节点管理子节点的功能
# manager 的出现就是为了这个功能
'''
Created on 2013-8-14
@author: lan (www.9miao.com)
'''
from twisted.python import log
from zope.interface import Interface
from zope.interface import implements
class _ChildsManager(Interface): #接口类（这里用到接口这种开发模式，有兴趣的可以看一下）
'''节点管理器接口'''
def __init__(self):
'''初始化接口'''
def getChildById(self,childId):
'''根据节点id获取节点实例'''
def getChildByName(self,childname):
'''根据节点的名称获取节点实例'''
def addChild(self,child):
'''添加一个child节点
@param child: Child object
'''
def dropChild(self,*arg,**kw):
'''删除一个节点'''
def callChild(self,*args,**kw):
'''调用子节点的接口'''
def callChildByName(self,*args,**kw):
'''调用子节点的接口
@param childname: str 子节点的名称
'''
def dropChildByID(self,childId):
'''删除一个child 节点
@param childId: Child ID
'''
def dropChildSessionId(self, session_id):
"""根据session_id删除child节点
"""
@implementer(_ChildsManager)
class ChildsManager(object):
'''
子节点管理器
因为装饰器implementer
用户必须得完成_ChildsManager的所有方法
'''
def __init__(self):
'''
初始化子节点管理器
'''
self._childs = {}
#第一步初始化子节点字典
#所有子节点对象都将以键值对的形式存储在这里
#key -> child的ID
#value -> child 对象，也就是子节点
def getChildById(self,childId):
'''
根据节点的ID获取节点实例
'''
return self._childs.get(childId)
def getChildByName(self,childname):
'''
根据节点的名称获取节点实例
遍历子节点
从中提取节点名称为childname的节点
'''
for key,child in self._childs.items():
if child.getName() == childname:
return self._childs[key]
return None
def addChild(self,child):
'''添加一个child节点
@param child: Child object
'''
key = child._id
if self._childs.has_key(key):
raise "child node %s exists"% key
self._childs[key] = child
def dropChild(self,child):
'''删除一个child 节点
@param child: Child Object
'''
key = child._id
try:
del self._childs[key]
except Exception,e:
log.msg(str(e))
def dropChildByID(self,childId):
'''通过ID删除一个child 节点
@param childId: Child ID
'''
try:
del self._childs[childId]
except Exception,e:
log.msg(str(e))
def callChild(self,childId,*args,**kw):
'''调用子节点的接口
@param childId: int 子节点的id
'''
child = self._childs.get(childId,None)
if not child:
log.err("child %s doesn't exists"%childId)
return
return child.callbackChild(*args,**kw)
def callChildByName(self,childname,*args,**kw):
'''通过节点名称调用子节点的接口
@param childname: str 子节点的名称
'''
child = self.getChildByName(childname)
if not child:
log.err("child %s doesn't exists"%childname)
return
return child.callbackChild(*args,**kw)
def getChildBYSessionId(self, session_id):
"""根据sessionID获取child节点信息
"""
for child in self._childs.values():
if child._transport.broker.transport.sessionno == session_id:
return child
return None
从代码中，我们基本上可以看出来这个类除了用于管理子节点的添加，移除，获取这种最基本的以外，还有callChild**，callChild函数首先取出子节点，然后再调用子节点的callbackChild函数。从字面意思上，我们基本就可以看出来，这是一个调用子节点函数的函数。至于怎么实现的，可以去看twisted的透明代理部分，官网都有详细的说明以及demo。
-
node.py
介绍了那么多关于子节点的内容，
下面我们正式开始揭开子节点的面纱。
#顾名思义，node.py就是根节点下面的子节点
'''
Created on 2013-8-14
@author: lan (www.9miao.com)
'''
from twisted.spread import pb
from twisted.internet import reactor
reactor = reactor
from reference import ProxyReference
def callRemote(obj,funcName,*args,**kw):
'''
远程调用（这里只是作为一个调用子节点的方法存在）
@param obj 子节点对象，也就是RemoteObject
@param funcName: str 远程方法名称
'''
return obj.callRemote(funcName, *args,**kw)
class RemoteObject(object):
'''远程调用对象
也就是真正的子节点'''
def __init__(self,name):
'''初始化远程调用对象
@param port: int 远程分布服的端口号
@param rootaddr: 根节点服务器地址
'''
self._name = name #本节点的节点名称
self._factory = pb.PBClientFactory() #twisted的透明代理客户端工厂
self._reference = ProxyReference() #twisted透明代理的代理通道
self._addr = None #root节点的节点地址（host,port）
def setName(self,name):
'''设置节点的名称'''
self._name = name
def getName(self):
'''获取节点的名称'''
return self._name
def connect(self,addr):
'''初始化远程调用对象'''
self._addr = addr # 保存远程节点地址
reactor.connectTCP(addr[0], addr[1], self._factory) # 连接远程节点地址
self.takeProxy() # 获取远程节点地址对象（这是一个异步操作，返回的是延时对象）
def reconnect(self):
'''重新连接'''
self.connect(self._addr)
def addServiceChannel(self,service):
'''
设置引用对象
'''
self._reference.addService(service)
def takeProxy(self):
'''
向远程服务端发送代理通道对象
twisted的双向透明代理规定的步骤
1.向服务器请求root对象
2.通过root对象向服务器发送自身的ProxyReference（代理通道）
3.双向连接完成
'''
deferedRemote = self._factory.getRootObject()
deferedRemote.addCallback(callRemote,'takeProxy',self._name,self._reference)
def callRemote(self,commandId,*args,**kw):
'''
这里就是正式的远程调用函数了，子节点调用父节点的方法
和建立双向透明代理类似，调用的步骤为：
1.获取远程root对象
2.通过root对象调用服务器函数
@param callRemote 这里调用的就是该文件顶部的那个同名函数
由于 addCallback会将 异步获取的 对象传入Callback 中
也就是传入 callRemote 这个函数内，所以最终实现的效果是 ：
self._factory.getRootObject().callRemote('callTarget', ,commandId,*args,**kw)
@param callTarget 这是firefly定义的远程调用函数函数名称
@param commandId 远程对象会根据 commandId 来最终绝对执行什么操作
'''
deferedRemote = self._factory.getRootObject()
return deferedRemote.addCallback(callRemote,'callTarget',commandId,*args,**kw)
-
reference.py（代理通道）
#coding:utf8
'''
Created on 2013-8-14
@author: lan (www.9miao.com)
'''
from twisted.spread import pb
from firefly.utils.services import Service
class ProxyReference(pb.Referenceable):
'''代理通道'''
def __init__(self):
'''初始化'''
self._service = Service('proxy')
def addService(self,service):
'''添加一条服务通道'''
self._service = service
def remote_callChild(self, command,*arg,**kw):
'''代理发送数据
'''
return self._service.callTarget(command,*arg,**kw)
这一部分是代理通道相关的代码，主要实现功能就是在子节点实例化的时候产生一个代理通道，然后在子节点连接上父节点之后通过调用takeProxy函数将自己的代理通道对象发送给父节点，代理成功后，父节点就可以调用子节点中约定的函数（这也被称为pb的反向调用）
-
父节点对象 -root.py
最后我们来看看分布式节点的中心root节点，当然这里的所谓中心并不代表只有一个root节点，比如暗黑世界里，直观的你就能发现master和gate都是root节点，对于master而言，gate又是他的子节点。同理，game同样可以作为一个root节点（当然在暗黑世界里，game是一个child节点），然后分裂出game1，game2，game3...，但同时，又是gate的子节点，这其中并不矛盾。
# root.py文件，顾名思义，是个根节点
'''
Created on 2013-8-14
分布式根节点
@author: lan (www.9miao.com)
'''
from twisted.python import log
from twisted.spread import pb
from manager import ChildsManager
from child import Child
class BilateralBroker(pb.Broker):
'''
'''
def connectionLost(self, reason):
'''
这里重写了pb.broker的连接丢失方法，用于子连接丢失后将子节点从根节点中移除
'''
clientID = self.transport.sessionno #获取断开的节点id
log.msg("node [%d] lose"%clientID)
self.factory.root.dropChildSessionId(clientID)# 移除断开的节点对象
pb.Broker.connectionLost(self, reason) #断开节点
class BilateralFactory(pb.PBServerFactory):
'''
重写 PBServerFactory 类，
目的只是为了重写pb.Broker的connectionLost方法，
而重写connectionLost方法只是为了将子节点断开后，
从根节点中将对象删除，保持根节点对于子节点信息存储的准确性
'''
protocol = BilateralBroker
class PBRoot(pb.Root):
'''
继承PB 协议的root节点
'''
def __init__(self,dnsmanager = ChildsManager()):
'''
初始化根节点
'''
self.service = None
self.childsmanager = dnsmanager # 创建子节点管理器
def addServiceChannel(self,service):
'''添加服务通道
@param service: Service Object(In bilateral.services)
'''
self.service = service #
def doChildConnect(self,name,transport):
"""当node节点连接时的处理
"""
pass
def dropChild(self,*args,**kw):
'''删除子节点记录'''
self.childsmanager.dropChild(*args,**kw)
def dropChildByID(self,childId):
'''删除子节点记录'''
self.doChildLostConnect(childId)
self.childsmanager.dropChildByID(childId)
def dropChildSessionId(self, session_id):
'''删除子节点记录'''
child = self.childsmanager.getChildBYSessionId(session_id)
if not child:
return
child_id = child._id
self.doChildLostConnect(child_id)
self.childsmanager.dropChildByID(child_id)
def doChildLostConnect(self,childId):
"""当node节点连接时的处理
"""
pass
def callChild(self,key,*args,**kw):
'''调用子节点的接口
@param childId: int 子节点的id
return Defered Object
'''
return self.childsmanager.callChild(key,*args,**kw)
def callChildByName(self,childname,*args,**kw):
'''调用子节点的接口
@param childId: int 子节点的id
return Defered Object
'''
return self.childsmanager.callChildByName(childname,*args,**kw)
# 这里remote_**格式的方法，是twisted透明代理方法的格式，以此命名的方法都可被远程调用
def remote_takeProxy(self,name,transport):
'''设置代理通道
@param addr: (hostname,port)hostname 根节点的主机名,根节点的端口
'''
log.msg('node [%s] takeProxy ready'%name)
child = Child(name,name) # 创建子节点
self.childsmanager.addChild(child) # 添加子节点
child.setTransport(transport) # 设置子节点连接对象
self.doChildConnect(name, transport) #连接子节点
def remote_callTarget(self,command,*args,**kw):
'''远程调用方法
@param commandId: int 指令号
@param data: str 调用参数
'''
data = self.service.callTarget(command,*args,**kw)
return data
-
最终，我们基本已经清楚分布式布局的核心，互相调用的原理
1. root节点服务会首先建立，监听例如1000端口 root
2. node节点则会在服务器来后第一时间去连接1000端口
｛node->connect()->root｝
3. node与root建立连接成功后，node节点会调用root节点的remote_takeProxy函数用以在root节点互相交换代理权
｛node->takeProxy()->callRemote('register')->childsmanager.addChildByNamePeer()｝
4. 至此root和node之间的连接已经建立成功了，当然建立连接的本质意义是为了实现相互调用，那么相互调用又是怎么实现呢？
5. root调用child（这是一个反向调用的过程）
｛root -> childsmanager.callChild() -> child.callbackChild() -> ProxyReference().callRemote()｝
6. child调用root（这是一个正向调用的过程）
{child -> callRemote()}