def serverstart():
    '''服务配置
    '''
    log.startLogging(sys.stdout)
    factory.addServiceChannel(service)
#     reactor.callLater(10,factory.pushObject,111,'asdfe',[0])
#     reactor.callLater(15,factory.loseConnection,0)
    reactor.listenTCP(1000,factory)
    reactor.run()
Exemple #2
0
def serverstart():
    '''服务配置
    '''
    log.startLogging(sys.stdout)
    factory.addServiceChannel(service)
    reactor.callLater(10,factory.pushObject,111,'asdfe',[0])
    reactor.callLater(15,factory.loseConnection,0)
    reactor.listenTCP(1000,factory)
    reactor.run()
Exemple #3
0
 def masterapp(self):
     """
     """
     config = self.__loadconfig()
     GlobalObject().json_config = config
     mastercnf = config.get('master')
     rootport = mastercnf.get('rootport')
     webport = mastercnf.get('webport')
     masterlog = mastercnf.get('log')
     self.root = PBRoot()
     rootservice = services.Service("rootservice")
     self.root.addServiceChannel(rootservice)
     self.webroot = Flask("master")
     GlobalObject().root = self.root
     GlobalObject().webroot = self.webroot
     if masterlog:
         log.addObserver(loogoo(masterlog))#日志处理
     log.startLogging(sys.stdout)
     import webapp
     import rootapp
     reactor.listenWSGI(webport, self.webroot)
     reactor.listenTCP(rootport, BilateralFactory(self.root))
Exemple #4
0
 def masterapp(self):
     """
     """
     config = json.load(open(self.configpath, 'r'))
     GlobalObject().json_config = config
     mastercnf = config.get('master')
     rootport = mastercnf.get('rootport')
     webport = mastercnf.get('webport')
     masterlog = mastercnf.get('log')
     self.root = PBRoot()
     rootservice = services.Service("rootservice")
     self.root.addServiceChannel(rootservice)
     self.webroot = Flask("master")
     GlobalObject().root = self.root
     GlobalObject().webroot = self.webroot
     if masterlog:
         log.addObserver(loogoo(masterlog))  #日志处理
     log.startLogging(sys.stdout)
     import webapp
     import rootapp
     reactor.listenWSGI(webport, self.webroot)
     reactor.listenTCP(rootport, BilateralFactory(self.root))
Exemple #5
0
#coding:utf8
'''
Created on 2011-10-17

@author: lan (www.9miao.com)
'''
from gfirefly.utils import services
from gfirefly.distributed.node import RemoteObject
from gtwisted.core import reactor
from gtwisted.utils import log
import sys

log.startLogging(sys.stdout)

reactor = reactor

addr = ('localhost', 9090)  #目标主机的地址
remote = RemoteObject('test_node')  #实例化远程调用对象

service = services.CommandService('reference')  #实例化一条服务对象
remote.addServiceChannel(service)


def serviceHandle(target):
    '''服务处理
    @param target: func Object
    '''
    service.mapTarget(target)


@serviceHandle
#coding:utf8
'''
Created on 2011-10-17

@author: lan (www.9miao.com)
'''
from gfirefly.utils import  services
from gfirefly.distributed.root import PBRoot,BilateralFactory
from gtwisted.core import reactor
from gtwisted.utils import log
import sys
reactor = reactor
log.startLogging(sys.stdout)
    
root = PBRoot()
ser = services.Service('test')
root.addServiceChannel(ser)


def serviceHandle(target):
    '''服务处理
    @param target: func Object
    '''
    ser.mapTarget(target)

@serviceHandle
def printData1(data,data1):
    print data,data1
    print "############################"
    d = root.callChild("test_node",1,u'Root测试')
    return data
Exemple #7
0
    def config(self,
               config,
               servername=None,
               dbconfig=None,
               memconfig=None,
               masterconf=None):
        '''配置服务器
        '''
        GlobalObject().json_config = config
        GlobalObject().remote_connect = self.remote_connect
        netport = config.get('netport')  #客户端连接
        webport = config.get('webport')  #http连接
        rootport = config.get('rootport')  #root节点配置
        self.remoteportlist = config.get('remoteport', [])  #remote节点配置列表
        if not servername:
            servername = config.get('name')  #服务器名称
        logpath = config.get('log')  #日志
        hasdb = config.get('db')  #数据库连接
        hasmem = config.get('mem')  #memcached连接
        app = config.get('app')  #入口模块名称
        cpuid = config.get('cpu')  #绑定cpu
        mreload = config.get('reload')  #重新加载模块名称
        self.servername = servername

        if netport:
            self.netfactory = LiberateFactory()
            netservice = services.CommandService("netservice")
            self.netfactory.addServiceChannel(netservice)
            reactor.listenTCP(netport, self.netfactory)

        if webport:
            self.webroot = Flask("servername")
            GlobalObject().webroot = self.webroot
            reactor.listenWSGI(webport, self.webroot)

        if rootport:
            self.root = PBRoot()
            rootservice = services.Service("rootservice")
            self.root.addServiceChannel(rootservice)
            reactor.listenTCP(rootport, BilateralFactory(self.root))

        for cnf in self.remoteportlist:
            rname = cnf.get('rootname')
            self.remote[rname] = RemoteObject(self.servername)

        if hasdb and dbconfig:
            if dbconfig.has_key("user") and dbconfig.has_key(
                    "host") and dbconfig.has_key("host"):
                dbpool.initPool({"default": dbconfig})
            else:
                dbpool.initPool(dbconfig)

        if hasmem and memconfig:
            urls = memconfig.get('urls')
            #             hostname = str(memconfig.get('hostname'))
            memcached_connect(urls)
            from gfirefly.dbentrust.util import M2DB_PORT, M2DB_HOST, ToDBAddress
            ToDBAddress().setToDBHost(memconfig.get("pubhost", M2DB_HOST))
            ToDBAddress().setToDBPort(memconfig.get("pubport", M2DB_PORT))

        if logpath:
            log.addObserver(loogoo(logpath))  #日志处理
        log.startLogging(sys.stdout)

        if cpuid:
            affinity.set_process_affinity_mask(os.getpid(), cpuid)
        GlobalObject().config(netfactory=self.netfactory,
                              root=self.root,
                              remote=self.remote)

        if app:
            __import__(app)
        if mreload:
            _path_list = mreload.split(".")
            GlobalObject().reloadmodule = __import__(mreload,
                                                     fromlist=_path_list[:1])

        if masterconf:
            masterport = masterconf.get('rootport')
            masterhost = masterconf.get('roothost')
            self.master_remote = RemoteObject(servername)
            GlobalObject().masterremote = self.master_remote
            import admin
            addr = ('localhost',
                    masterport) if not masterhost else (masterhost, masterport)
            self.master_remote.connect(addr)
Exemple #8
0
    def config(self, config, servername=None, dbconfig=None,
                memconfig=None, masterconf=None):
        '''配置服务器
        '''
        GlobalObject().json_config = config
        GlobalObject().remote_connect = self.remote_connect
        netport = config.get('netport')#客户端连接
        webport = config.get('webport')#http连接
        rootport = config.get('rootport')#root节点配置
        self.remoteportlist = config.get('remoteport',[])#remote节点配置列表
        if not servername:
            servername = config.get('name')#服务器名称
        logpath = config.get('log')#日志
        hasdb = config.get('db')#数据库连接
        hasmem = config.get('mem')#memcached连接
        app = config.get('app')#入口模块名称
        cpuid = config.get('cpu')#绑定cpu
        mreload = config.get('reload')#重新加载模块名称
        self.servername = servername
            
        if netport:
            self.netfactory = LiberateFactory()
            netservice = services.CommandService("netservice")
            self.netfactory.addServiceChannel(netservice)
            reactor.listenTCP(netport,self.netfactory)
            
        if webport:
            self.webroot = Flask("servername")
            GlobalObject().webroot = self.webroot
            reactor.listenWSGI(webport, self.webroot)
            
        if rootport:
            self.root = PBRoot()
            rootservice = services.Service("rootservice")
            self.root.addServiceChannel(rootservice)
            reactor.listenTCP(rootport, BilateralFactory(self.root))
            
        for cnf in self.remoteportlist:
            rname = cnf.get('rootname')
            self.remote[rname] = RemoteObject(self.servername)
            
        if hasdb and dbconfig:
            if dbconfig.has_key("user") and dbconfig.has_key("host") and dbconfig.has_key("host"):
                dbpool.initPool({"default":dbconfig})
            else:
                dbpool.initPool(dbconfig)
            
        if hasmem and memconfig:
            urls = memconfig.get('urls')
#             hostname = str(memconfig.get('hostname'))
            memcached_connect(urls)
            from gfirefly.dbentrust.util import M2DB_PORT,M2DB_HOST,ToDBAddress
            ToDBAddress().setToDBHost(memconfig.get("pubhost",M2DB_HOST))
            ToDBAddress().setToDBPort(memconfig.get("pubport",M2DB_PORT))
            
        if logpath:
            log.addObserver(loogoo(logpath))#日志处理
        log.startLogging(sys.stdout)
        
        if cpuid:
            affinity.set_process_affinity_mask(os.getpid(), cpuid)
        GlobalObject().config(netfactory = self.netfactory, root=self.root,
                    remote = self.remote)
        
        if app:
            __import__(app)
        if mreload:
            _path_list = mreload.split(".")
            GlobalObject().reloadmodule = __import__(mreload,fromlist=_path_list[:1])
        
        if masterconf:
            masterport = masterconf.get('rootport')
            masterhost = masterconf.get('roothost')
            self.master_remote = RemoteObject(servername)
            GlobalObject().masterremote = self.master_remote
            import admin
            addr = ('localhost',masterport) if not masterhost else (masterhost,masterport)
            self.master_remote.connect(addr)        
Exemple #9
0
 def config(self, config, servername=None, dbconfig=None,
             memconfig=None, masterconf=None):
     '''配置服务器
     '''
     GlobalObject().json_config = config
     netport = config.get('netport')#客户端连接
     webport = config.get('webport')#http连接
     rootport = config.get('rootport')#root节点配置
     self.remoteportlist = config.get('remoteport',[])#remote节点配置列表
     if not servername:
         servername = config.get('name')#服务器名称
     logpath = config.get('log')#日志
     hasdb = config.get('db')#数据库连接
     hasmem = config.get('mem')#memcached连接
     app = config.get('app')#入口模块名称
     cpuid = config.get('cpu')#绑定cpu
     mreload = config.get('reload')#重新加载模块名称
     self.servername = servername
     if masterconf:
         masterport = masterconf.get('rootport')
         masterhost = masterconf.get('roothost')
         self.master_remote = RemoteObject(servername)
         addr = ('localhost',masterport) if not masterhost else (masterhost,masterport)
         self.master_remote.connect(addr)
         GlobalObject().masterremote = self.master_remote
         
     if netport:
         self.netfactory = LiberateFactory()
         netservice = services.CommandService("netservice")
         self.netfactory.addServiceChannel(netservice)
         reactor.listenTCP(netport,self.netfactory)
         
     if webport:
         self.webroot = Flask("master")
         GlobalObject().webroot = self.webroot
         reactor.listenTCP(webport, self.webroot)
         
     if rootport:
         self.root = PBRoot()
         rootservice = services.Service("rootservice")
         self.root.addServiceChannel(rootservice)
         reactor.listenTCP(rootport, BilateralFactory(self.root))
         
     for cnf in self.remoteportlist:
         rname = cnf.get('rootname')
         self.remote[rname] = RemoteObject(self.servername)
         
     if hasdb and dbconfig:
         log.msg(str(dbconfig))
         dbpool.initPool(**dbconfig)
         
     if hasmem and memconfig:
         urls = memconfig.get('urls')
         hostname = str(memconfig.get('hostname'))
         mclient.connect(urls, hostname)
         
     if logpath:
         log.addObserver(loogoo(logpath))#日志处理
     log.startLogging(sys.stdout)
     
     if cpuid:
         affinity.set_process_affinity_mask(os.getpid(), cpuid)
     GlobalObject().config(netfactory = self.netfactory, root=self.root,
                 remote = self.remote)
     if app:
         __import__(app)
     if mreload:
         _path_list = mreload.split(".")
         GlobalObject().reloadmodule = __import__(mreload,fromlist=_path_list[:1])
     GlobalObject().remote_connect = self.remote_connect
     import admin