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
def get_listener(self, address, family):
from gevent.server import _tcp_listener
return _tcp_listener(address, backlog=self.backlog, reuse_addr=1, family=family)
# -*- 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)
