def sync_call(self, apiname, args={}, timeout=5):
""" 给定参数args，同步调用RPCServer的apiname服务,
返回该服务的处理结果。如果超时，返回None。
Args:
apiname (str): 服务API名称。
args (dict): 给服务API的参数。
handler (function): 回调函数。
"""
log.debug('RPCClient [%s] sync_call: %s' % (self._name, apiname))
if not isinstance(args, dict):
self._timeout = 0
self._sync_ret = None
raise InvalidRPCClientArguments(argtype=type(args))
self.rid += 1
args['apiname'] = apiname
args['rid'] = self.rid
with self._sync_call_time_lock:
self._sync_call_time = datetime.now()
self._timeout = timeout
with self._handlers_lock:
self._handlers[self.rid] = None #
self._event_engine.emit(Event(self.EVENT_FROM_CLIENT, args))
self._waiting_server_data()
ret = self._sync_ret
#self._sync_ret = None
return ret
def test_zmq_eventengine():
"""测试函数"""
import sys
from datetime import datetime
import time
def simpletest(event):
print str(datetime.now()), event.route
print 'test_zmq_eventengine.....'
ee = ZMQEventEngine()
ee.register(Event.TIMER, simpletest)
timer = Timer(ee)
ee.start()
timer.start()
event = Event(route=Event.TIMER)
ee.emit(event)
## @TODO test_unregister
#time.sleep(2)
#ee.stop_timer()
#time.sleep(2)
#ee.resume_timer()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
timer.stop()
ee.stop()
sys.exit(0)
def _run_timer(self):
event = Event(route=Event.TIMER)
while True:
with self._timer_pause_condition:
if not self._timer_active:
self._timer_pause_condition.wait()
self._event_engine.emit(event)
# 等待
sleep(self._timer_sleep)
def call(self, apiname, args, handler):
""" 给定参数args，异步调用RPCServer的apiname服务,
返回结果做为回调函数handler的参数。
Args:
apiname (str): 服务API名称。
args (dict): 给服务API的参数。
handler (function): 回调函数。
"""
if not isinstance(args, dict):
raise InvalidRPCClientArguments(argtype=type(args))
assert (not handler == None)
log.debug('RPCClient [%s] sync_call: %s' % (self._name, apiname))
self.rid += 1
args['apiname'] = apiname
args['rid'] = self.rid
self._event_engine.emit(Event(self.EVENT_FROM_CLIENT, args))
with self._handlers_lock:
self._handlers[self.rid] = handler
def _process_request(self, event):
args = event.args
rid = args['rid']
apiname = args['apiname']
del args['rid']
del args['apiname']
log.debug('RPCServer [%s] process: %s' % (self._name, apiname))
try:
with self._routes_lock:
handler = self._routes[apiname]
# @TODO async
ret = handler(**args)
except Exception as e:
log.exception(e)
else:
args = {'ret': ret, 'rid': rid}
log.debug('RPCServer [%s] emit %s' %
(self._name, str(self.EVENT_FROM_SERVER)))
self._event_engine.emit(Event(self.EVENT_FROM_SERVER, args))
def _run_client(self):
message = self._client_recv_event_socket.recv()
event = Event.message_to_event(message)
log.debug("[engine: %s] receive message: %s" % (self._name, event))
self._queue_engine.emit(event)
def unregister(self, route, handler):
self._queue_engine.unregister(route, handler)
if route not in self._routes:
self._client_recv_event_socket.setsockopt(zmq.UNSUBSCRIBE,
Event.message_header(route))
def register(self, route, handler):
""" 接受指定的事件。 """
if self._queue_engine.register(route, handler):
self._client_recv_event_socket.setsockopt(zmq.SUBSCRIBE,
Event.message_header(route))
def emit(self, event):
""" client or event"""
msg = Event.event_to_message(event)
self._emit_event_socket.send(msg)
return
def _run_client(self):
message = self._client_recv_event_socket.recv()
event = Event.message_to_event(message)
log.debug("[engine: %s] receive message: %s" % (self._name, event))
self._queue_engine.emit(event)
def unregister(self, route, handler):
self._queue_engine.unregister(route, handler)
if route not in self._routes:
self._client_recv_event_socket.setsockopt(
zmq.UNSUBSCRIBE, Event.message_header(route))
def register(self, route, handler):
""" 接受指定的事件。 """
if self._queue_engine.register(route, handler):
self._client_recv_event_socket.setsockopt(
zmq.SUBSCRIBE, Event.message_header(route))
def emit(self, event):
""" client or event"""
msg = Event.event_to_message(event)
self._emit_event_socket.send_string(msg)
return
log.debug("[engine: %s] broadcast message: %s" %
(self._name, strevent))
if __name__ == '__main__':
import time, datetime, sys
def simpletest(event):
six.print_(str(datetime.datetime.now()), event)
ee = ZMQEventEngine('test')
ee.register(Event.TIMER, simpletest)
timer = Timer(ee)
ee.start()
timer.start()
event = Event(route=Event.TIMER)
timer.stop()
time.sleep(2)
timer.resume()
time.sleep(2)
timer.stop()
client = ZMQEventEngine('test')
event = Event(route=Event.TIMER, args={'data': 'from client'})
client.start()
client.emit(event)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
ee.stop()
def emit(self, event):
msg = Event.event_to_message(event)
self._emit_event_socket.send_string(msg)
return
