def main(): print 'Starting Python server...' listener = _tcp_listener(('',9090)) number_of_processes = cpu_count() - 1 print 'Starting %s processes' % number_of_processes for i in range(number_of_processes): Process(target=serve_forever, args=(listener,)).start() serve_forever(listener)
def main(): print 'Starting Python server...' listener = _tcp_listener(('', 9090)) number_of_processes = cpu_count() - 1 print 'Starting %s processes' % number_of_processes for i in range(number_of_processes): Process(target=serve_forever, args=(listener, )).start() serve_forever(listener)
def __init__(self, port, cluster_eth): #statqueue = statqueue """创建多个engine让它平均到多个进程上,性能问题要进一步调试""" self.maxbuffer = '' [setattr(self, x, {}) for x in store] """取得厂商数量,避免每次去查询""" self.db = PostgresSQLEngine() self.mcastsqueue = Queue() self.mcastrqueue = Queue() #self.cluster = ClusterSRV(cluster_eth) print "start cluster multicast" # vendor = QueryDB.get_vendor_table() # s = sql.select([vendor]) # rn = self.db.execute(s) # self.vendors = set() # for n in rn: # self.vendors.add(n[3:11]) #devlist = [''.join([n.devid,n.chost]) for n in session.query(type(devclass)).all()] self.vendors = self.db.get_vendor_to_set() self.lock = Lock() self.prefunc = { STUN_METHOD_ALLOCATE: self.handle_allocate_request, # 小机登录方法 STUN_METHOD_CHECK_USER: self.handle_chkuser_request, STUN_METHOD_REGISTER: self.handle_register_request, STUN_METHOD_BINDING: self.handle_app_login_request # app端登录方法 } #认证后的处理 self.postfunc = { STUN_METHOD_CHANNEL_BIND: self.handle_app_bind_device, # APP 绑定小机的命令 #STUN_METHOD_REFRESH:self.handle_refresh_request, STUN_METHOD_MODIFY: self.handle_modify_bind_item, #修改绑定的信息 STUN_METHOD_DELETE: self.handle_delete_bind_item, #删除现有的绑定 STUN_METHOD_PULL: self.handle_app_pull, STUN_METHOD_QUERY: self.handle_dev_query # 小机查询命令 } #self.server = StreamServer(('0.0.0.0',3478),self.handle_new_accept,backlog = 8192) #self.server.serve_forever() self.listener = _tcp_listener(('0.0.0.0', 3478), 65536, 1) #self.server = StreamServer(('0.0.0.0',3478),self.handle_new_accept,backlog=100000) #self.server.start() #for i in xrange(1): # Process(target=self.server_forever).start() self.fwdcounter = {} self.errqueue = {} self.statqueue = {} self.fwdqueue = {} self.statlog = {} self.errlog = {} self.fwdlog = {} self.startime = time.time() for i in xrange(mp.cpu_count() - 1): Process(target=self.start_srv).start()
def __init__(self,port,cluster_eth): #statqueue = statqueue """创建多个engine让它平均到多个进程上,性能问题要进一步调试""" self.maxbuffer = '' [setattr(self,x,{}) for x in store] """取得厂商数量,避免每次去查询""" self.db = PostgresSQLEngine() self.mcastsqueue = Queue() self.mcastrqueue = Queue() #self.cluster = ClusterSRV(cluster_eth) print "start cluster multicast" # vendor = QueryDB.get_vendor_table() # s = sql.select([vendor]) # rn = self.db.execute(s) # self.vendors = set() # for n in rn: # self.vendors.add(n[3:11]) #devlist = [''.join([n.devid,n.chost]) for n in session.query(type(devclass)).all()] self.vendors = self.db.get_vendor_to_set() self.lock = Lock() self.prefunc= { STUN_METHOD_ALLOCATE:self.handle_allocate_request, # 小机登录方法 STUN_METHOD_CHECK_USER:self.handle_chkuser_request, STUN_METHOD_REGISTER:self.handle_register_request, STUN_METHOD_BINDING:self.handle_app_login_request # app端登录方法 } #认证后的处理 self.postfunc={ STUN_METHOD_CHANNEL_BIND:self.handle_app_bind_device, # APP 绑定小机的命令 #STUN_METHOD_REFRESH:self.handle_refresh_request, STUN_METHOD_MODIFY:self.handle_modify_bind_item, #修改绑定的信息 STUN_METHOD_DELETE:self.handle_delete_bind_item, #删除现有的绑定 STUN_METHOD_PULL:self.handle_app_pull, STUN_METHOD_QUERY:self.handle_dev_query # 小机查询命令 } #self.server = StreamServer(('0.0.0.0',3478),self.handle_new_accept,backlog = 8192) #self.server.serve_forever() self.listener = _tcp_listener(('0.0.0.0',3478),65536,1) #self.server = StreamServer(('0.0.0.0',3478),self.handle_new_accept,backlog=100000) #self.server.start() #for i in xrange(1): # Process(target=self.server_forever).start() self.fwdcounter = {} self.errqueue = {} self.statqueue = {} self.fwdqueue = {} self.statlog = {} self.errlog = {} self.fwdlog = {} self.startime = time.time() for i in xrange(mp.cpu_count()-1): Process(target=self.start_srv).start()
def get_listener(port): """ Get TCP socket listener. @param port: int or basestring - int = Internet port, basestring = relative file name of UNIX domain socket @return listener: gevent._socket2.socket """ assert isinstance(port, (int, basestring)), (port, type(port)) family = AF_INET if isinstance(port, int) else AF_UNIX if family == AF_INET: host = '0.0.0.0' if config['listen_any'] else config['host'] addr = (host, port) else: addr = os.path.join(config['unix_sock_dir'], port) listener = None while 1: try: if family == AF_UNIX: if not os.path.exists(config['unix_sock_dir']): try: os.mkdir(config['unix_sock_dir']) except OSError as e: if 'exists' not in repr(e): # Racing with other worker. raise if os.path.exists(addr): os.remove(addr) listener = _tcp_listener(addr, family=family, reuse_addr=True, backlog=config['backlog']) break except Exception as e: if 'Address already in use' not in repr(e): raise log.error('w{}: {}'.format(state.worker, e)) time.sleep(config['block_seconds']) log.info('w{}: listening {}'.format(state.worker, addr)) return listener
from multiprocessing import Process, current_process, cpu_count import pprint import string from collections import defaultdict from gevent.queue import Queue import re import time from gevent.pool import Pool as GPool from gevent.queue import Queue def note(format, *args): sys.stderr.write('[%s]\t%s\n' % (current_process().name, format%args)) word_split = re.compile(r'[ ]') listener = _tcp_listener(('0.0.0.0', 8891)) def send_bye(socket): socket.send('BYE 0000') def send_msg(socket, msg): try: str_to_send = 'RCV ' + string.zfill(len(msg) + 1, 4) + ' ' + msg # print "Sending: ", str_to_send socket.send(str_to_send) except: pass def send_msg_to_subscriber(publisher, to, msg): try: # print "Sending to PUB:" + to + '-- message is: ' + msg
data_list.append( OrderedDict([('dag_id', task.dag_id), ('task_id', task.task_id), ('execution_date', execution_date), ('runtime', self.seconds_to(runtime)), ('average', self.seconds_to(average))])) else: continue return jsonify(data_list) if __name__ == '__main__': api = Api(app) api.add_resource(DagView, "{}/dagview".format(INIT_URL)) api.add_resource(DagControl, "{}/dagcontrol".format(INIT_URL)) api.add_resource(TaskView, "{}/taskview".format(INIT_URL)) api.add_resource(GetLog, "{}/getlog".format(INIT_URL)) api.add_resource(TaskControl, "{}/taskcontrol".format(INIT_URL)) api.add_resource(WorkerView, "{}/workerview".format(INIT_URL)) api.add_resource(LongRunningView, "{}/longrunning".format(INIT_URL)) number_of_processes = 5 listen = _tcp_listener((HOST_NAME, 80)) def serve_forever(listener): WSGIServer(listener, app).serve_forever() for i in range(number_of_processes): Process(target=serve_forever, args=(listen, )).start() serve_forever(listen)
def get_listener(self, address, family): from gevent.server import _tcp_listener return _tcp_listener(address, backlog=self.backlog, reuse_addr=1, family=family)
def serve(cls, game, host='', port=5000, compression=False, language=GameLanguage.LITTLEPY, avg_game_count=10, multiplayer_scoring_interval=20, num_of_threads=None, game_data_path="temp_game", avg_game_func=average, debug=False, reuse_addr=None): cls.game = game cls.host = host cls.port = port cls.compression = compression cls.language = language cls.avg_game_count = avg_game_count cls._avg_game_func = avg_game_func cls.gamedb = GameDB(game_data_path) # setup anonymous school with an anonymous user if not cls.gamedb.is_school_token(ANONYMOUS_SCHOOL): cls.gamedb.add_new_school(_token=ANONYMOUS_SCHOOL) if not cls.gamedb.is_user_token(ANONYMOUS_USER): cls.gamedb.get_new_token(ANONYMOUS_SCHOOL, _token=ANONYMOUS_USER) if not cls.gamedb.is_comp_token(ANONYMOUS_COMP): cls.gamedb.add_new_competition(_token=ANONYMOUS_COMP) print("Building www cache...") cls.gamedb.www_cache.safe_replace_cache( os.path.join(os.path.split(__file__)[0], "www")) if issubclass(game, GridGame): cls.charset = cls.__copy_in_charset(game.CHAR_SET) cls.app = flask.Flask( __name__.split('.')[0], static_url_path='', static_folder=cls.gamedb.www_cache.static_dir, template_folder=cls.gamedb.www_cache.template_dir, root_path=cls.gamedb.www_cache.root_dir) @cls.app.template_filter('markdown') def markdown_filter(data): from flask import Markup from markdown import markdown return Markup(markdown(data)) if cls.compression: # BUUT WHAT ABOUT BREACH ATTACKS import flask_compress flask_compress.Compress(cls.app) cls.register(cls.app) cls.__load_language() print("Starting server at {}:{}".format(cls.host, cls.port)) if cls.game.MULTIPLAYER and multiplayer_scoring_interval >= 0: if debug: print("Starting scoring process...") scoring_process = RollingMultiplayerCompRunner( multiplayer_scoring_interval, cls.gamedb, cls.game, cls.compiler, debug=debug) # scoring_process = MultiplayerCompRunner(multiplayer_scoring_interval, cls.gamedb, cls.game, cls.compiler, debug=debug) scoring_process.start() if debug: print("Debug Enabled.") cls.app.run(cls.host, cls.port) else: from gevent.server import _tcp_listener from gevent.pywsgi import WSGIServer listener = _tcp_listener((cls.host, cls.port), reuse_addr=reuse_addr) def serve_forever(listener): try: WSGIServer(listener, cls.app).serve_forever() except KeyboardInterrupt: pass if num_of_threads is None: num_of_threads = multiprocessing.cpu_count() for i in range(num_of_threads): Process(target=serve_forever, args=(listener, )).start() serve_forever(listener) print("Dying...") if cls.game.MULTIPLAYER: scoring_process.stop() print("All good :)")
def get_listener(host, port): from gevent.server import _tcp_listener return _tcp_listener((host, port))
save_score(userid, courseid, score, orgkey) return render_template('score.html', user=get_user_name(userid, orgkey), coursecode=coursecode, score=score) ################################################################################ # serve ################################################################################ def serve_forever(listener): pywsgi.WSGIServer(listener, application=app, log=None).serve_forever() if __name__ == '__main__': if this_is_debugging == True: app.run(host="0.0.0.0", port=8080, debug=this_is_debugging) else: number_of_processes = 5 listener = _tcp_listener(('', 8084)) for i in range(number_of_processes): print("starting process" + str(i)) Process(target=serve_forever, args=(listener, )).start() serve_forever(listener)
def __init__(self): self.listener = _tcp_listener(('0.0.0.0', port), reuse_addr=1) self.access_log = access_log self.error_log = errors_log self.ipaddress = ipaddress self.client_address = None self.client_raddress = None self.pprocess_id = os.getpid() #parent pid self.process_id = None self.request_line = None self.http_user_agent = None self.http_host = None self.status = None self.real_ip = None self.file_size = None self.time_start = timeit.default_timer() self.time_finish = 0 self.server = None self.serverName = "OctoFlowRest" try: self.redisPool = redis.ConnectionPool(host=config.redisServer, port=config.redisPort, db=config.redisDB) self.redis = redis.Redis(connection_pool=self.redisPool) except: self.redisPool = None self.redis = None self.redisPSName = config.pubsubName self.mqServer = config.mqServer self.mqAuth = config.mqAuth self.session_name = config.sessionName self.session_domain = None #config.sessionDomain self.session_id = "" self.session_key = "" self.session_val = "" self.headers = "" self.session_expires = config.sessionExpires self.session_info = {} self.hostname = hostname self.request_method = "" self.environ = "" self.config = config self.txid = None self.__stop = False self.tokenSecret = config.tokenSecret self.logger1 = OctoflowLogger('octoFlowRest1') self.logger2 = OctoflowLogger('octoFlowRest2') self.infoFile = '{0}/{1}-{2}.log'.format(config.restLogDir, config.restLogLevel.lower(), self.hostname) self.errorFile = '{0}/error-{1}.log'.format(config.restLogDir, self.hostname) #self.logger1.streamHandler(config.restLogLevel) self.log_info = self.logger1.timeRotateHandler( filename=self.infoFile, when="m", interval=60, backupCount=0, level=config.restLogLevel) #self.logger2.streamHandler("ERROR") self.log_error = self.logger2.timeRotateHandler( filename=self.errorFile, when="m", interval=60, backupCount=0, level="ERROR") self.mqQueName = config.mqQueName self.adminQueue = config.adminQueue
# -*- coding: utf-8 -*- from gevent.server import _tcp_listener from gevent import pywsgi from gevent.monkey import patch_all; patch_all() from multiprocessing import Process, cpu_count def hello_world(env, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return ["<b>hello world</b>"] listener = _tcp_listener(('0.0.0.0', 7000)) def serve_forever(listener): pywsgi.WSGIServer(listener, hello_world, log=open('/dev/null', 'w')).serve_forever() for i in range(cpu_count() - 1): Process(target=serve_forever, args=(listener,)).start() serve_forever(listener)
# -*- coding: utf-8 -*- from gevent.server import _tcp_listener from gevent import pywsgi from gevent.monkey import patch_all patch_all() from multiprocessing import Process, cpu_count def hello_world(env, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return ["<b>hello world</b>"] listener = _tcp_listener(('0.0.0.0', 7000)) def serve_forever(listener): pywsgi.WSGIServer(listener, hello_world, log=open('/dev/null', 'w')).serve_forever() for i in range(cpu_count() - 1): Process(target=serve_forever, args=(listener, )).start() serve_forever(listener)