def run(self):
self.init()
# 监听指令
commands = ztq_core.get_command_queue(self.worker_name)
while True:
try:
command = commands.pop()
if command['command'] == 'report':
worker_state = ztq_core.get_worker_state()
worker_state[self.worker_name] = report(self.login_time)
elif command['command'] == 'updatedriver':
# TODO
#async_drive_config()
pass
elif command['command'] == 'updateworker':
queue = ztq_core.get_worker_config()
set_job_threads(queue[self.worker_name])
elif command['command'] == 'kill':
kill_transform(pid=command['pid'], timestamp=command['timestamp'])
elif command['command'] == 'cancel':
cancel_transform(pid=command['pid'], timestamp=command['timestamp'])
except KeyboardInterrupt:
import os
# 实际上调用的是command_execute.clear_thread
os.sys.exitfunc()
os._exit(0)
def run(self):
self.init()
# 监听指令
commands = ztq_core.get_command_queue(self.worker_name)
while True:
try:
command = commands.pop()
if command['command'] == 'report':
worker_state = ztq_core.get_worker_state()
worker_state[self.worker_name] = report(self.login_time)
elif command['command'] == 'updatedriver':
# TODO
#async_drive_config()
pass
elif command['command'] == 'updateworker' and \
CONFIG['server'].get('active_config', 'false').lower() == 'true':
queue = ztq_core.get_worker_config()
set_job_threads(queue[self.worker_name])
elif command['command'] == 'kill':
kill_transform(pid=command['pid'], timestamp=command['timestamp'])
elif command['command'] == 'cancel':
cancel_transform(pid=command['pid'], timestamp=command['timestamp'])
except ztq_core.ConnectionError, e:
logger.error('ERROR: redis command connection error: %s' % str(e))
time.sleep(3)
except ztq_core.ResponseError, e:
logger.error('ERROR: redis command response error: %s' % str(e))
time.sleep(3)
def run(self):
self.init()
# 监听指令
commands = ztq_core.get_command_queue(self.worker_name)
while True:
try:
command = commands.pop()
if command['command'] == 'report':
worker_state = ztq_core.get_worker_state()
worker_state[self.worker_name] = report(self.login_time)
elif command['command'] == 'updatedriver':
# TODO
#async_drive_config()
pass
elif command['command'] == 'updateworker':
queue = ztq_core.get_worker_config()
set_job_threads(queue[self.worker_name])
elif command['command'] == 'kill':
kill_transform(pid=command['pid'],
timestamp=command['timestamp'])
elif command['command'] == 'cancel':
cancel_transform(pid=command['pid'],
timestamp=command['timestamp'])
except KeyboardInterrupt:
import os
# 实际上调用的是command_execute.clear_thread
os.sys.exitfunc()
os._exit(0)
def get_error_queue_jobs(error_queue_name, sindex=0, eindex=-1):
error_queue = ztq_core.get_error_queue(error_queue_name)
workers_state = ztq_core.get_worker_state()
for hash_key in error_queue[sindex:eindex]:
error_job = ztq_core.get_error_hash(error_queue_name)[hash_key]
tmp_job = {}
tmp_job['json'] = json.dumps(error_job)
tmp_job['_queue_name'] = error_queue_name
worker_name = error_job['runtime']['worker']
# 检查worker是否存在,存在则取得服务器ip
if worker_name in workers_state:
tmp_job['_server'] = workers_state[worker_name]['ip']
else:
tmp_job['_server'] = worker_name
tmp_job['_created'] = datetime.datetime.fromtimestamp(
error_job['runtime'].get('create', 0))
tmp_job['_start'] = datetime.datetime.fromtimestamp(
error_job['runtime'].get('start', 0))
tmp_job['_end'] = datetime.datetime.fromtimestamp(
error_job['runtime'].get('end', 0))
tmp_job['_reason'] = ''.join(error_job['runtime']['reason'])
tmp_job['_file'] = error_job['kw'].get('comment',
error_job['kw'].get('path', ''))
tmp_job['_error_mime'] = error_job['process'].get('to_mime', '')
tmp_job['_detail'] = pprint.pformat(error_job)
tmp_job['hash_id'] = urllib.quote(hash_key)
yield tmp_job
def main():
""" 主函数 """
conf_file = ''
# 用户指定一个配置文件
if len(sys.argv) > 1:
conf_file = sys.argv[1]
init_config(conf_file)
server = get_configs('server')
alias = safe_get_host('server', 'alias')
active_config = server.get('active_config', 'false')
# 动态注册task
for module in server['modules'].split():
try:
importlib.import_module(module)
except ImportError:
raise Exception('Not imported the %s module' % module)
# 连结服务器
ztq_core.setup_redis('default', host=server['host'], port=int(server['port']), db=int(server['db']))
# 开启一个命令线程
command_thread = CommandThread(worker_name=alias)
sys.stdout.write('Starting server in PID %s\n'%os.getpid())
worker_state = ztq_core.get_worker_state()
if active_config.lower() == 'true' and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
queue = ztq_core.get_worker_config()
if command_thread.worker_name in queue:
set_job_threads(queue[command_thread.worker_name])
elif get_configs('queues'):
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
job_threads = {}
queue_config = ztq_core.get_queue_config()
for queue_name, sleeps in get_configs('queues').items():
queue_config[queue_name] = {'title': queue_name} # for ztq_app
job_threads[queue_name] = [
{'interval': int(sleep)} for sleep in sleeps.split(',')
]
queue_config[queue_name] = {'name':queue_name, 'title':queue_name, 'widget': 5}
init_job_threads(job_threads)
loggers = get_configs('log')
initlog(
loggers.get('key', 'ztq_worker'),
loggers.get('handler_file'),
loggers.get('level', 'ERROR'),
)
# 不是以线程启动
command_thread.run()
def main(config):
""" 主函数
config: {'server': {host:, port:, db:}
}
"""
server = config["server"]
# 动态注册task
for module in server["modules"].split():
try:
__import__(module)
except ImportError:
modules = module.split(".")
__import__(modules[0], globals(), locals(), modules[1])
# 连结服务器
redis_host = server["host"]
redis_port = int(server["port"])
redis_db = int(server["db"])
ztq_core.setup_redis("default", host=redis_host, port=redis_port, db=redis_db)
# 开启一个命令线程
alias = server.get("alias", "")
if not alias:
alias = get_ip()
server["alias"] = alias
command_thread = CommandThread(worker_name=alias)
sys.stdout.write("Starting server in PID %s\n" % os.getpid())
worker_state = ztq_core.get_worker_state()
active_config = server.get("active_config", "false")
if active_config.lower() == "true" and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
queue = ztq_core.get_worker_config()
if command_thread.worker_name in queue:
set_job_threads(queue[command_thread.worker_name])
elif config["queues"]:
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
job_threads = {}
for queue_name, sleeps in config["queues"].items():
job_threads[queue_name] = [{"interval": int(sleep)} for sleep in sleeps.split(",")]
if not queue_config.get(queue_name, []):
queue_config[queue_name] = {"name": queue_name, "title": queue_name, "widget": 5}
init_job_threads(job_threads)
loggers = config["log"]
initlog(loggers.get("key", "ztq_worker"), loggers.get("handler_file"), loggers.get("level", "ERROR"))
# 不是以线程启动
command_thread.run()
def init(self):
""" 开机初始化工作 """
reboot = False
worker_state = ztq_core.get_worker_state()
if self.worker_name in worker_state:
# 重启，读取服务器配置信息
reboot = True
# 记录系统日志
system_log = ztq_core.get_system_log_queue()
system_log.push(dict( host=CONFIG['server']['alias'],
alias=self.worker_name,
type=reboot and 'reboot' or 'power',
timestamp=self.login_time,))
# 报告机器状态
worker_state[self.worker_name] = report(self.login_time)
def config_worker(request):
"""对worker进行配置管理
"""
url_action = request.params.get('action', '')
dispatcher_config = ztq_core.get_dispatcher_config()
worker_weight = dispatcher_config['worker_weight']
# 获取用户请求操作
worker_id = request.matchdict['id']
# 根据操作类型进行权重调整,
if url_action == 'stop_worker':
#停止worker
worker_weight[worker_id] = 0
elif url_action == 'enable':
#启用worker
worker_weight[worker_id] = 5
elif url_action == 'worker_down':
#降低worker权重
worker_weight[worker_id] -= 1
if worker_weight[worker_id] < 1: worker_weight[worker_id] = 1
elif url_action == 'worker_up':
#提升worker权重
worker_weight[worker_id] += 1
if worker_weight[worker_id] > 10: worker_weight[worker_id] = 10
elif url_action == 'delete':
#删除还没启用的worker,删除操作不会导致调度配置更新
if worker_id in worker_weight: # 没有启用的情况
worker_weight.pop(worker_id)
workers_dict = ztq_core.get_worker_state()
del workers_dict[worker_id]
worker_job = ztq_core.get_job_state(worker_id)
for job_name, job_status in worker_job.items():
del worker_job[job_name]
ztq_core.set_dispatcher_config(dispatcher_config)
return HTTPFound(location='/workerstatus')
elif url_action == 'update':
# 发报告指令到各命令队列让worker报告自身状态
worker_list = ztq_core.get_all_worker()
for worker_name in worker_list:
if worker_name == worker_id:
utils.send_command(worker_name, 'report')
time.sleep(1)
return HTTPFound(location='/workerstatus')
# 更新调度策略并进行调度
ztq_core.set_dispatcher_config(dispatcher_config)
utils.dispatch()
return HTTPFound(location='/workerstatus')
def config_worker(request):
"""对worker进行配置管理
"""
url_action = request.params.get('action','')
dispatcher_config = ztq_core.get_dispatcher_config()
worker_weight = dispatcher_config['worker_weight']
# 获取用户请求操作
worker_id = request.matchdict['id']
# 根据操作类型进行权重调整,
if url_action == 'stop_worker':
#停止worker
worker_weight[worker_id] = 0
elif url_action == 'enable':
#启用worker
worker_weight[worker_id] = 5
elif url_action == 'worker_down' :
#降低worker权重
worker_weight[worker_id] -= 1
if worker_weight[worker_id] < 1: worker_weight[worker_id] = 1
elif url_action == 'worker_up' :
#提升worker权重
worker_weight[worker_id] += 1
if worker_weight[worker_id] >10: worker_weight[worker_id] = 10
elif url_action == 'delete':
#删除还没启用的worker,删除操作不会导致调度配置更新
if worker_id in worker_weight: # 没有启用的情况
worker_weight.pop(worker_id)
workers_dict = ztq_core.get_worker_state()
del workers_dict[worker_id]
worker_job = ztq_core.get_job_state(worker_id)
for job_name, job_status in worker_job.items():
del worker_job[job_name]
ztq_core.set_dispatcher_config(dispatcher_config)
return HTTPFound(location = '/workerstatus')
elif url_action == 'update':
# 发报告指令到各命令队列让worker报告自身状态
worker_list = ztq_core.get_all_worker()
for worker_name in worker_list:
if worker_name == worker_id:
utils.send_command(worker_name, 'report')
time.sleep(1)
return HTTPFound(location = '/workerstatus')
# 更新调度策略并进行调度
ztq_core.set_dispatcher_config(dispatcher_config)
utils.dispatch()
return HTTPFound(location = '/workerstatus')
def get_worker_list():
dispatcher_config = ztq_core.get_dispatcher_config()
worker_weight = dispatcher_config['worker_weight']
workers_dict = ztq_core.get_worker_state().items()
for worker_name, worker_status in workers_dict:
worker_status['_worker_name'] = worker_name
worker_status['_started'] = \
datetime.datetime.fromtimestamp(worker_status['started'])
worker_status['_timestamp'] = \
datetime.datetime.fromtimestamp(worker_status['timestamp'])
worker_status['_worker_weight'] = worker_weight.get(worker_name, 0)
# 检查worker是否在工作
cmd_queue = ztq_core.get_command_queue(worker_name)
# 如果指令队列不为空的话,意味着worker没工作,属于下线状态
if cmd_queue: worker_status['_active'] = u'shutdown'
elif worker_status['_worker_weight'] == 0:
worker_status['_active'] = u'ldle'
else:
worker_status['_active'] = u'work'
# 获取worker开了多少个线程
worker_job = ztq_core.get_job_state(worker_name)
worker_status['_threads'] = []
for thread_name, thread_status in worker_job.items():
thread_status['_detail'] = pprint.pformat(thread_status)
thread_status['_name'] = thread_name
thread_status['_comment'] = thread_status['kw'].get(
'comment', thread_status['process'].get('comment', ''))
thread_status['_pid'] = thread_status['process'].get('pid', -1)
ident = unicode(thread_status['process'].get('ident', -1))
if ident in worker_status['traceback']:
thread_status['_thread_detail'] = pprint.pformat(
worker_status['traceback'][ident])
# 任务进行了多少时间
used_time = int(time.time()) - thread_status['process']['start']
if used_time > 3600:
used_time = u'%.2f小时' % (used_time / 3600.0)
elif used_time > 60:
used_time = u'%.2f分钟' % (used_time / 60.0)
thread_status['_take_time'] = used_time
worker_status['_threads'].append(thread_status)
yield worker_status
def get_worker_list():
workers_dict = ztq_core.get_worker_state().items()
for worker_name, worker_status in workers_dict:
worker_status['_worker_name'] = worker_name
worker_status['_started'] = \
datetime.datetime.fromtimestamp(worker_status['started'])
worker_status['_timestamp'] = \
datetime.datetime.fromtimestamp(worker_status['timestamp'])
# 检查worker是否在工作
cmd_queue = ztq_core.get_command_queue(worker_name)
# 如果指令队列不为空的话,意味着worker没工作,属于下线状态
if cmd_queue:
worker_status['_active'] = u'shutdown'
else:
worker_status['_active'] = u'work'
# 获取worker开了多少个线程
worker_job = ztq_core.get_job_state(worker_name)
worker_status['_threads'] = []
for thread_name,thread_status in worker_job.items():
thread_status['_detail'] = pprint.pformat(thread_status)
thread_status['_name'] = thread_name
thread_status['_comment'] = thread_status['kw'].get('comment',thread_status['process'].get('comment', ''))
thread_status['_pid'] = thread_status['process'].get('pid', -1)
ident = unicode(thread_status['process'].get('ident', -1))
if ident in worker_status['traceback']:
thread_status['_thread_detail'] = pprint.pformat(worker_status['traceback'][ident])
# 任务进行了多少时间
used_time = int(time.time())-thread_status['process']['start']
if used_time > 3600:
used_time = u'%.2f小时' % (used_time / 3600.0)
elif used_time > 60:
used_time = u'%.2f分钟' % (used_time / 60.0)
thread_status['_take_time'] = used_time
worker_status['_threads'].append(thread_status)
yield worker_status
def get_error_queue_jobs(error_queue_name, sindex=0, eindex=-1):
error_queue = ztq_core.get_error_queue(error_queue_name)
workers_state = ztq_core.get_worker_state()
for hash_key in error_queue[sindex:eindex]:
error_job = ztq_core.get_error_hash(error_queue_name)[hash_key]
tmp_job={}
tmp_job['json'] = json.dumps(error_job)
tmp_job['_queue_name'] = error_queue_name
worker_name = error_job['runtime']['worker']
# 检查worker是否存在,存在则取得服务器ip
if worker_name in workers_state:
tmp_job['_server'] = workers_state[worker_name]['ip']
else: tmp_job['_server'] = worker_name
tmp_job['_created'] = datetime.datetime.fromtimestamp(error_job['runtime'].get('create',0))
tmp_job['_start'] = datetime.datetime.fromtimestamp(error_job['runtime'].get('start',0))
tmp_job['_end'] = datetime.datetime.fromtimestamp(error_job['runtime'].get('end',0))
tmp_job['_reason'] = ''.join(error_job['runtime']['reason'])
tmp_job['_file'] = error_job['kw'].get('comment', error_job['kw'].get('path', ''))
tmp_job['_error_mime'] = error_job['process'].get('to_mime','')
tmp_job['_detail'] = pprint.pformat(error_job)
tmp_job['hash_id'] = urllib.quote(hash_key)
yield tmp_job
def config_worker(request):
"""对worker进行配置管理
"""
url_action = request.params.get('action', '')
# 获取用户请求操作
worker_id = request.matchdict['id']
if url_action == 'delete':
#删除还没启用的worker,删除操作不会导致调度配置更新
workers_dict = ztq_core.get_worker_state()
del workers_dict[worker_id]
worker_job = ztq_core.get_job_state(worker_id)
for job_name, job_status in worker_job.items():
del worker_job[job_name]
return HTTPFound(location='/workerstatus')
elif url_action == 'update':
# 发报告指令到各命令队列让worker报告自身状态
worker_list = ztq_core.get_all_worker()
for worker_name in worker_list:
if worker_name == worker_id:
utils.send_command(worker_name, 'report')
time.sleep(1)
return HTTPFound(location='/workerstatus')
return HTTPFound(location='/workerstatus')
def config_worker(request):
"""对worker进行配置管理
"""
url_action = request.params.get('action','')
# 获取用户请求操作
worker_id = request.matchdict['id']
if url_action == 'delete':
#删除还没启用的worker,删除操作不会导致调度配置更新
workers_dict = ztq_core.get_worker_state()
del workers_dict[worker_id]
worker_job = ztq_core.get_job_state(worker_id)
for job_name, job_status in worker_job.items():
del worker_job[job_name]
return HTTPFound(location = '/workerstatus')
elif url_action == 'update':
# 发报告指令到各命令队列让worker报告自身状态
worker_list = ztq_core.get_all_worker()
for worker_name in worker_list:
if worker_name == worker_id:
utils.send_command(worker_name, 'report')
time.sleep(1)
return HTTPFound(location = '/workerstatus')
return HTTPFound(location = '/workerstatus')
def main(config):
""" 主函数
config: {'server': {host:, port:, db:}
}
"""
server = config['server']
module_path = server['module_path']
sys.path.append(module_path)
# 动态注册task
for module in server['modules'].split():
try:
__import__(module)
except ImportError:
modules = module.split('.')
__import__(modules[0], globals(), locals(), modules[1])
# 连结服务器
redis_host = server['host']
redis_port = int(server['port'])
redis_db = int(server['db'])
# 是否启用 sentinel
enable_sentinel = server['enable_sentinel'].lower() == 'true'
# 对应的 sentinel service_name
sentinel_name = server['sentinel_name']
if enable_sentinel:
# 当启用 sentinel 时
# 配置的host, port, db等信息变为了sentinel的主机信息
ztq_core.setup_sentinel('default', [(redis_host, redis_port)],
[sentinel_name], db = redis_db)
else:
ztq_core.setup_redis('default', host=redis_host, port=redis_port, db=redis_db)
# 开启一个命令线程
alias = server.get('alias', '')
if not alias:
alias = get_ip()
server['alias'] = alias
command_thread = CommandThread(worker_name=alias)
sys.stdout.write('Starting server in PID %s\n'%os.getpid())
worker_state = ztq_core.get_worker_state()
active_config = server.get('active_config', 'false')
if active_config.lower() == 'true' and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
queue = ztq_core.get_worker_config()
if command_thread.worker_name in queue:
set_job_threads(queue[command_thread.worker_name])
elif config['queues']:
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
job_threads = {}
for queue_name, sleeps in config['queues'].items():
job_threads[queue_name] = [
{'interval': int(sleep)} for sleep in sleeps.split(',')
]
if not queue_config.get(queue_name, []):
queue_config[queue_name] = {'name':queue_name, 'title':queue_name, 'widget': 5}
init_job_threads(job_threads)
loggers = config['log']
initlog(
loggers.get('key', 'ztq_worker'),
loggers.get('handler_file'),
loggers.get('level', 'ERROR'),
)
# 不是以线程启动
command_thread.run()
def main(config, thread=False):
""" 主函数
config: {'server': {host:, port:, db:}
}
"""
server = config['server']
# 动态注册task
for module in server['modules'].split():
try:
__import__(module)
except ImportError:
modules = module.split('.')
__import__(modules[0], globals(), locals(), modules[1])
# 连结服务器
redis_host = server['host']
redis_port = int(server['port'])
redis_db = int(server['db'])
ztq_core.setup_redis('default',
host=redis_host,
port=redis_port,
db=redis_db)
# 开启一个命令线程
alias = server.get('alias', '')
if not alias:
alias = get_ip()
server['alias'] = alias
command_thread = CommandThread(worker_name=alias)
sys.stdout.write('Starting server in PID %s\n' % os.getpid())
worker_state = ztq_core.get_worker_state()
active_config = server.get('active_config', 'false')
# 计算那些是需要根据线上配置启动的队列
active_queue_config = {}
if active_config.lower(
) == 'true' and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
worker_config = ztq_core.get_worker_config()
active_queue_config = worker_config.get(command_thread.worker_name, {})
# 根据本地配置，启动的队列
local_queue_config = {}
if config['queues']:
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
for queue_name, sleeps in config['queues'].items():
# 线上配置稍后再设置
if queue_name in active_queue_config: continue
local_queue_config[queue_name] = [{
'interval': int(sleep)
} for sleep in sleeps.split(',')]
if not queue_config.get(queue_name, []):
queue_config[queue_name] = {
'name': queue_name,
'title': queue_name,
'widget': 5
}
# 合并线上和线下的配置
active_queue_config.update(local_queue_config)
init_job_threads(active_queue_config)
loggers = config['log']
initlog(
loggers.get('key', 'ztq_worker'),
loggers.get('handler_file'),
loggers.get('level', 'ERROR'),
)
# 不是以线程启动
if thread:
command_thread.setDaemon(True)
command_thread.start()
else:
command_thread.run()
def main(config):
""" 主函数
config: {'server': {host:, port:, db:}
}
"""
server = config['server']
# 动态注册task
for module in server['modules'].split():
try:
__import__(module)
except ImportError:
modules = module.split('.')
__import__(modules[0], globals(), locals(), modules[1])
# 连结服务器
redis_host = server['host']
redis_port = int(server['port'])
redis_db = int(server['db'])
ztq_core.setup_redis('default', host=redis_host, port=redis_port, db=redis_db)
# 开启一个命令线程
alias = server.get('alias', '')
if not alias:
alias = get_ip()
server['alias'] = alias
command_thread = CommandThread(worker_name=alias)
sys.stdout.write('Starting server in PID %s\n'%os.getpid())
worker_state = ztq_core.get_worker_state()
active_config = server.get('active_config', 'false')
# 计算那些是需要根据线上配置启动的队列
active_queue_config = {}
if active_config.lower() == 'true' and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
worker_config = ztq_core.get_worker_config()
active_queue_config = worker_config.get(command_thread.worker_name, {})
# 根据本地配置，启动的队列
local_queue_config = {}
if config['queues']:
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
for queue_name, sleeps in config['queues'].items():
# 线上配置稍后再设置
if queue_name in active_queue_config: continue
local_queue_config[queue_name] = [
{'interval': int(sleep)} for sleep in sleeps.split(',')
]
if not queue_config.get(queue_name, []):
queue_config[queue_name] = {'name':queue_name, 'title':queue_name, 'widget': 5}
# 合并线上和线下的配置
active_queue_config.update(local_queue_config)
init_job_threads(active_queue_config)
loggers = config['log']
initlog(
loggers.get('key', 'ztq_worker'),
loggers.get('handler_file'),
loggers.get('level', 'ERROR'),
)
# 不是以线程启动
command_thread.run()
def main():
""" 主函数 """
conf_file = ''
# 用户指定一个配置文件
if len(sys.argv) > 1:
conf_file = sys.argv[1]
init_config(conf_file)
server = get_configs('server')
alias = safe_get_host('server', 'alias')
active_config = server.get('active_config', 'false')
# 动态注册task
for module in server['modules'].split():
try:
__import__(module)
except ImportError:
raise Exception('Not imported the %s module' % module)
# 连结服务器
ztq_core.setup_redis('default',
host=server['host'],
port=int(server['port']),
db=int(server['db']))
# 开启一个命令线程
command_thread = CommandThread(worker_name=alias)
sys.stdout.write('Starting server in PID %s\n' % os.getpid())
worker_state = ztq_core.get_worker_state()
if active_config.lower(
) == 'true' and command_thread.worker_name in worker_state:
# 如果服务器有这个机器的配置信息，需要自动启动工作线程
queue = ztq_core.get_worker_config()
if command_thread.worker_name in queue:
set_job_threads(queue[command_thread.worker_name])
elif get_configs('queues'):
# 把worker监视队列的情况上报到服务器
queue_config = ztq_core.get_queue_config()
# 如果配置有queues，自动启动线程监视
job_threads = {}
for queue_name, sleeps in get_configs('queues').items():
job_threads[queue_name] = [{
'interval': int(sleep)
} for sleep in sleeps.split(',')]
if not queue_config.get(queue_name, []):
queue_config[queue_name] = {
'name': queue_name,
'title': queue_name,
'widget': 5
}
init_job_threads(job_threads)
loggers = get_configs('log')
initlog(
loggers.get('key', 'ztq_worker'),
loggers.get('handler_file'),
loggers.get('level', 'ERROR'),
)
# 不是以线程启动
command_thread.run()
