Esempio n. 1
0
class RemoteObject(object):
    '''远程调用对象 一个实例
    '''
    def __init__(self, name, index=1, ref=None):
        '''初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        '''
        self.setName(name)
        self.index = index
        self._factory = pb.PBClientFactory()
        if ref is None:
            self._reference = ProxyReference()
        else:
            self._reference = ref
        self._addr = None

    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):
        '''像远程服务端发送代理通道对象
        '''
        deferedRemote = self._factory.getRootObject()
        deferedRemote.addCallback(callRemote, 'takeProxy', self._name,
                                  self._reference)

    def callRemote(self, commandId, *args, **kw):
        '''远程调用'''
        deferedRemote = self._factory.getRootObject()
        return deferedRemote.addCallback(callRemote, 'callTarget', commandId,
                                         *args, **kw)
Esempio n. 2
0
class RemoteObject(object):
    '''远程调用对象'''
    instance = None

    @classmethod
    def getInstance(cls, name=None):
        if cls.instance is None:
            cls.instance = RemoteObject(name)
        return cls.instance

    def __init__(self, name=None):
        self._name = name
        self._factory = pb.PBClientFactory()
        self._reference = ProxyReference()
        self._addr = None

    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 getServiceChannel(self):
        return self._reference.getService()

    def disconnectCallback(self, callback):
        self._factory.stopFactory = callback

    def takeProxy(self):
        deferedRemote = self._factory.getRootObject()
        deferedRemote.addCallback(callRemote, 'takeProxy', self._name, self._reference)

    def callRemote(self, commandId, *args, **kw):
        '''回调root的接口'''
        deferedRemote = self._factory.getRootObject()
        return deferedRemote.addCallback(callRemote, 'callTarget', commandId, *args, **kw)
Esempio n. 3
0
class RemoteObject(object):
    '''远程调用对象'''
    
    def __init__(self,name):
        '''初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        '''
        self._name = name
        self._factory = pb.PBClientFactory()
        self._reference = ProxyReference()
        self._addr = None
        
    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):
        '''像远程服务端发送代理通道对象
        '''
        deferedRemote = self._factory.getRootObject()
        deferedRemote.addCallback(callRemote,'takeProxy',self._name,self._reference)
    
    def callRemote(self,commandId,*args,**kw):
        '''远程调用'''
        deferedRemote = self._factory.getRootObject()
        return deferedRemote.addCallback(callRemote,'callTarget',commandId,*args,**kw)
Esempio n. 4
0
class RemoteObject(object):
    """远程调用对象"""

    def __init__(self, name):
        """初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        """
        self._name = name
        self._factory = pb.PBClientFactory()
        self._reference = ProxyReference()

    def setName(self, name):
        """设置节点的名称"""
        self._name = name

    def getName(self):
        """获取节点的名称"""
        return self._name

    def connect(self, addr):
        """初始化远程调用对象"""
        reactor.connectTCP(addr[0], addr[1], self._factory)
        self.takeProxy()

    def addServiceChannel(self, service):
        """设置引用对象"""
        self._reference.addService(service)

    def takeProxy(self):
        """像远程服务端发送代理通道对象
        """
        deferedRemote = self._factory.getRootObject()
        deferedRemote.addCallback(callRemote, "takeProxy", self._name, self._reference)

    def callRemote(self, commandId, *args, **kw):
        """远程调用"""
        deferedRemote = self._factory.getRootObject()
        return deferedRemote.addCallback(callRemote, "callTarget", commandId, *args, **kw)
Esempio n. 5
0
class RemoteObject(object):
    '''远程调用对象'''
    def __init__(self, name, timeout=600):
        '''初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        '''
        self._name = name
        self._factory = BilateralClientFactory()
        self._reference = ProxyReference()
        self._addr = None
        self._timeout = timeout

    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, addr=()):
        '''重新连接'''
        if addr:
            self.connect(addr)
        else:
            self.connect(self._addr)

    def addServiceChannel(self, service):
        '''设置引用对象'''
        self._reference.addService(service)

    def takeProxy(self):
        '''像远程服务端发送代理通道对象
        '''
        self._factory._protocol.setProxyReference(self._reference)
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        deferedRemote.callRemoteNotForResult('takeProxy', self._name)

    def callRemote(self, commandId, *args, **kw):
        """默认远程调用,等待结果放回
        """
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteForResult('callTarget', commandId,
                                                 *args, **kw)

    def callRemoteForResult(self, commandId, *args, **kw):
        '''远程调用,并等待结果放回
        '''
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteForResult('callTarget', commandId,
                                                 *args, **kw)

    def callRemoteNotForResult(self, commandId, *args, **kw):
        '''远程调用,不需要结果放回
        '''
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteNotForResult('callTarget', commandId,
                                                    *args, **kw)
Esempio n. 6
0
class RemoteObject(object):
    """远程调用对象"""
    def __init__(self, name, timeout=600):
        """初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        """
        self._name = name
        self._factory = BilateralClientFactory()
        self._reference = ProxyReference()
        self._addr = None
        self._timeout = timeout

    def __getattr__(self, fun):
        class RpcFunctionWrapper:
            def __init__(self, fun, handle):
                self._fun = fun
                self._handle = handle

            def __call__(self, *arg, **kw):
                if not self._handle:
                    return False
                return self._handle('callTarget', self._fun, *arg, **kw)

        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        if not deferedRemote:
            return RpcFunctionWrapper(fun, None)

        if fun.endswith('remote'):
            return RpcFunctionWrapper(fun, deferedRemote.callRemoteForResult)

        if fun.endswith('remote_noresult'):
            return RpcFunctionWrapper(fun,
                                      deferedRemote.callRemoteNotForResult)

        raise Exception('error rpc name, must endwith <remote>:%s' % fun)
        return None

    def __getitem__(self, node):
        class NodeWrapper:
            def __init__(self, node, handle):
                self._handle = handle
                self._node = node

            def __getattr__(self, fun):
                class RpcFunctionWrapper:
                    def __init__(self, node, fun, handle):
                        self._fun = fun
                        self._node = node
                        self._handle = handle

                    def __call__(self, *arg, **kw):
                        if not self._handle:
                            return False
                        return self._handle('transit', self._node, self._fun,
                                            *arg, **kw)

                if fun.endswith('remote'):
                    return RpcFunctionWrapper(self._node, fun,
                                              self._handle.callRemoteForResult)

                if fun.endswith('remote_noresult'):
                    return RpcFunctionWrapper(
                        self._node, fun, self._handle.callRemoteNotForResult)

        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return NodeWrapper(node, deferedRemote)

    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, addr=()):
        """重新连接"""
        if addr:
            self.connect(addr)
        else:
            self.connect(self._addr)

    def addServiceChannel(self, service):
        """设置引用对象"""
        self._reference.addService(service)

    def takeProxy(self):
        """像远程服务端发送代理通道对象 """
        self._factory._protocol.setProxyReference(self._reference)
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        deferedRemote.callRemoteNotForResult('takeProxy', self._name)
Esempio n. 7
0
class RemoteObject(object):
    '''远程调用对象'''
    def __init__(self, name, rname):
        '''初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        '''
        self._name = name
        self._rname = rname
        self._factory = pb.PBClientFactory()
        self._reference = ProxyReference()
        self._addr = None

        self._factory.clientConnectionLost = self.clientConnectionLost
        self._factory.clientConnectionFailed = self.clientConnectionFailed
        self.srclientConnectionMade = self._factory.clientConnectionMade
        self._factory.clientConnectionMade = self.clientConnectionMade

    def clientConnectionLost(self, connector, reason, reconnecting=1):
        log.err("clientConnectionLost for %s: %s, %s, %s" %
                (self._rname, str(reason), self._addr, reconnecting))
        self.reconnect()

    def clientConnectionFailed(self, connector, reason):
        log.err("clientConnectionFailed for %s :%s, %s" %
                (self._rname, str(reason), self._addr))
        self.reconnect()

    def clientConnectionMade(self, broker):
        log.msg("clientConnectionMade for ", self._rname)
        self.srclientConnectionMade(broker)
        self.takeProxy()

    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)

    def reconnect(self):
        '''重新连接'''
        self.connect(self._addr)

    def addServiceChannel(self, service):
        '''设置引用对象'''
        self._reference.addService(service)

    def takeProxy(self):
        '''像远程服务端发送代理通道对象
        '''
        log.msg("takeProxy ....")
        deferedRemote = self._factory.getRootObject()
        deferedRemote.addCallback(callRemote, 'takeProxy', self._name,
                                  self._reference)

    def callRemote(self, commandId, *args, **kw):
        '''远程调用'''
        deferedRemote = self._factory.getRootObject()
        return deferedRemote.addCallback(callRemote, 'callTarget', commandId,
                                         *args, **kw)
Esempio n. 8
0
class RemoteObject(object):
    '''远程调用对象'''
    
    def __init__(self,name,timeout=600):
        '''初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        '''
        self._name = name
        self._factory = BilateralClientFactory(self)
        self._reference = ProxyReference()
        self._addr = None
        self._timeout = timeout
        
    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,addr=()):
        '''重新连接'''
        if addr:
            self.connect(addr)
        else:
            self.connect(self._addr)
        
    def addServiceChannel(self,service):
        '''设置引用对象'''
        self._reference.addService(service)
        
    def takeProxy(self):
        '''像远程服务端发送代理通道对象
        '''
        self._factory._protocol.setProxyReference(self._reference)
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        deferedRemote.callRemoteNotForResult('takeProxy',self._name)
        
    def callRemote(self,commandId,*args,**kw):
        """默认远程调用,等待结果放回
        """
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteForResult('callTarget',commandId,*args,**kw)
    
    def callRemoteForResult(self,commandId,*args,**kw):
        '''远程调用,并等待结果放回
        '''
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteForResult('callTarget',commandId,*args,**kw)
    
    def callRemoteNotForResult(self,commandId,*args,**kw):
        '''远程调用,不需要结果放回
        '''
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return deferedRemote.callRemoteNotForResult('callTarget',commandId,*args,**kw)
Esempio n. 9
0
class RemoteObject(object):
    """远程调用对象"""

    def __init__(self, name, timeout=600):
        """初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        """
        self._name = name
        self._factory = BilateralClientFactory()
        self._reference = ProxyReference()
        self._addr = None
        self._timeout = timeout

    def __getattr__(self, fun):
        class RpcFunctionWrapper:
            def __init__(self, fun, handle):
                self._fun = fun
                self._handle = handle

            def __call__(self, *arg):
                if not self._handle:
                    return False
                return self._handle('callTarget', self._fun, *arg)

        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        if not deferedRemote:
            return RpcFunctionWrapper(fun, None)

        if fun.endswith('remote'):
            return RpcFunctionWrapper(fun, deferedRemote.callRemoteForResult)

        if fun.endswith('remote_noresult'):
            return RpcFunctionWrapper(fun,
                                      deferedRemote.callRemoteNotForResult)

        raise Exception('error rpc name, must endwith <remote>:%s' % fun)
        return None

    def __getitem__(self, node):
        class NodeWrapper:
            def __init__(self, node, handle):
                self._handle = handle
                self._node = node

            def __getattr__(self, fun):
                class RpcFunctionWrapper:
                    def __init__(self, node, fun, handle):
                        self._fun = fun
                        self._node = node
                        self._handle = handle

                    def __call__(self, *arg):
                        if not self._handle:
                            return False
                        return self._handle('transit',
                                            self._node,
                                            self._fun, *arg)

                if fun.endswith('remote'):
                    return RpcFunctionWrapper(self._node,
                                              fun,
                                              self._handle.callRemoteForResult)

                if fun.endswith('remote_noresult'):
                    return RpcFunctionWrapper(self._node,
                                              fun,
                                              self._handle.callRemoteNotForResult)

        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        return NodeWrapper(node, deferedRemote)

    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, addr=()):
        """重新连接"""
        if addr:
            self.connect(addr)
        else:
            self.connect(self._addr)

    def addServiceChannel(self, service):
        """设置引用对象"""
        self._reference.addService(service)

    def takeProxy(self):
        """像远程服务端发送代理通道对象 """
        self._factory._protocol.setProxyReference(self._reference)
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        deferedRemote.callRemoteNotForResult('takeProxy', self._name)

    def is_connected(self):
        deferedRemote = self._factory.getRootObject(timeout=self._timeout)
        if deferedRemote.broker:
            return True
        else:
            return False