def wapper():
if self.delay:
eventlet.sleep(self.delay)
data = self.notify[keyword]
target = Target(**data.pop('target'))
func = getattr(get_client(), data.pop('method'))
func(target, **data)
def target_endpoint(endpoint):
return Target(fanout=endpoint, namespace=endpoint)
def target_server(agent_type, host, fanout=False):
return Target(topic='%s.%s' % (AGENT, agent_type),
server=host,
fanout=AGENT if fanout else None,
namespace=manager_group.name)
def target_anyone(agent_type):
return Target(topic='%s.%s' % (AGENT, agent_type),
namespace=manager_group.name)
def target_all(fanout=False):
return Target(topic='%s.*' % AGENT,
fanout=AGENT if fanout else None,
namespace=manager_group.name)
def target_rpcserver(host=None, fanout=False):
return Target(topic='%s' % SERVER,
server=host,
fanout=SERVER if fanout else None,
namespace=manager_group.name)
from simpleservice.rpc.service import LauncheRpcServiceBase
from simpleservice.server import ServerWrapper
from simpleservice.server import launch
from simpleutil.config import cfg
from simpleutil.log import log as logging
from simpleservice.rpc.target import Target
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
config_file = 'C:\\Users\\loliz_000\\Desktop\\etc\\agent.conf'
config_files = [
config_file,
]
# config.set_default_for_default_log_levels(['routes=INFO', ])
CONF(project='agent', default_config_files=config_files)
config.configure()
agent_group = cfg.OptGroup(name='agent', title='agent options')
CONF.register_group(agent_group)
logging.setup(CONF, 'agent')
default_logging.captureWarnings(True)
servers = []
manager = base.ManagerBase(Target(topic='agent', namespace='manager'))
rpc_server = LauncheRpcServiceBase(manager)
wsgi_wrapper = ServerWrapper(rpc_server, workers=1)
servers.append(wsgi_wrapper)
launch(servers)
from simpleutil.config import cfg
from simpleutil.log import log as logging
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
config_file = 'C:\\Users\\loliz_000\\Desktop\\etc\\agent.conf'
config_files=[config_file, ]
# config.set_default_for_default_log_levels(['routes=INFO', ])
CONF(project='rpclient', default_config_files=config_files)
config.configure()
# agent_group = cfg.OptGroup(name='agent', title='agent options')
# CONF.register_group(agent_group)
logging.setup(CONF, 'rpclient')
default_logging.captureWarnings(True)
client = RPCClientBase(CONF['rabbit'])
target = Target(namespace='manager', topic='agent')
# ret = client.cast(target, {'request_id':'f**k'}, {'method':'show', 'args':{'data':[1,2,3,4,56]}})
ret = client.call(target, {'request_id':'f**k'}, {'method':'show', 'args':{'data':[1,2,3,4,56]}}, timeout=0.5)
print ret
def rpc_asyncrequest(self, ctxt,
asyncrequest, rpc_target, rpc_method,
rpc_ctxt, rpc_args):
"""async respone check"""
session = get_session()
finishtime = ctxt.get('finishtime', None)
asyncrequest = AsyncRequest(**asyncrequest)
pre_run = ctxt.pop('pre_run', None)
after_run = ctxt.pop('after_run', None)
post_run = ctxt.pop('post_run', None)
if finishtime and int(realnow()) >= finishtime:
asyncrequest.resultcode = manager_common.RESULT_OVER_FINISHTIME
asyncrequest.result = 'Async request over finish time'
asyncrequest.status = manager_common.FINISH
try:
session.add(asyncrequest)
session.flush()
except DBDuplicateEntry:
LOG.warning('Async request record DBDuplicateEntry')
except DBError as e:
LOG.error('Async request record DBError %s: %s' % (e.__class__.__name__, e.message))
return
if not self.is_active:
asyncrequest.resultcode = manager_common.SCHEDULER_STATUS_ERROR
asyncrequest.result = 'Rpc server not active now'
asyncrequest.status = manager_common.FINISH
session.add(asyncrequest)
session.flush()
return
try:
if pre_run:
pre_run = self._compile('pre', pre_run)
if after_run:
after_run = self._compile('after', after_run)
if post_run:
post_run = self._compile('post', post_run)
except (KeyError, jsonutils.ValidationError):
asyncrequest.resultcode = manager_common.SCHEDULER_EXECUTER_ERROR
asyncrequest.result = 'Rpc server can not find executer or ctxt error'
asyncrequest.status = manager_common.FINISH
session.add(asyncrequest)
session.flush()
return
# except Exception:
# LOG.exception('wtf')
# raise
if rpc_ctxt.get('agents') is None:
wait_agents = [x[0] for x in model_query(session, Agent.agent_id,
filter=Agent.status > manager_common.DELETED).all()]
else:
wait_agents = rpc_ctxt.get('agents')
rpc_ctxt.update({'request_id': asyncrequest.request_id,
'expire': asyncrequest.expire,
'finishtime': asyncrequest.finishtime})
try:
target = Target(**rpc_target)
rpc = get_client()
except Exception:
LOG.error('Prepare rpc clinet error')
asyncrequest.resultcode = manager_common.SCHEDULER_PREPARE_ERROR
asyncrequest.result = 'Rpc server prepare rpc clinet error'
asyncrequest.status = manager_common.FINISH
session.add(asyncrequest)
session.flush()
return
if pre_run:
try:
pre_run.run(asyncrequest, wait_agents)
except RpcServerCtxtException as e:
asyncrequest.resultcode = manager_common.SCHEDULER_EXECUTER_ERROR
asyncrequest.result = 'Rpc server ctxt pre function fail: %s' % e.message
asyncrequest.status = manager_common.FINISH
session.add(asyncrequest)
session.flush()
return
session.add(asyncrequest)
session.flush()
LOG.debug('Try cast rpc method %s' % rpc_method)
try:
rpc.cast(target, ctxt=rpc_ctxt, msg={'method': rpc_method, 'args': rpc_args})
except AMQPDestinationNotFound:
asyncrequest.resultcode = manager_common.SEND_FAIL
asyncrequest.result = 'Async %s request send fail, AMQPDestinationNotFound' % rpc_method
asyncrequest.status = manager_common.FINISH
session.flush()
return
LOG.debug('Cast %s to %s success' % (asyncrequest.request_id, target.to_dict()))
if after_run:
try:
after_run.run(asyncrequest, wait_agents)
except RpcServerCtxtException as e:
asyncrequest.result = 'Async request %s cast success, ' \
'ctxt after function error~%s' % (rpc_method, e.message)
else:
asyncrequest.result = 'Async request %s cast success' % rpc_method
finally:
session.flush()
request_id = asyncrequest.request_id
finishtime = asyncrequest.finishtime
deadline = asyncrequest.deadline + 1
expire = asyncrequest.expire
if expire:
storage = get_cache()
else:
storage = session
def check_respone():
wait = finishtime - int(time.time())
# 先等待3秒,可以做一次提前检查
if wait > 3:
eventlet.sleep(3)
no_response_agents = set(wait_agents)
interval = int(wait / 10)
if interval < 3:
interval = 3
elif interval > 10:
interval = 10
not_overtime = 2
while True:
no_response_agents = responeutils.norespones(storage=storage,
request_id=request_id,
agents=no_response_agents)
if not no_response_agents:
break
if int(time.time()) < finishtime:
eventlet.sleep(interval)
if int(time.time()) > deadline:
not_overtime -= 1
if not not_overtime:
break
eventlet.sleep(1)
LOG.debug('Not response agents count %d' % len(no_response_agents))
bulk_data = []
agent_time = int(time.time())
for agent_id in no_response_agents:
data = dict(request_id=request_id,
agent_id=agent_id,
agent_time=agent_time,
server_time=agent_time,
resultcode=manager_common.RESULT_OVER_FINISHTIME,
result='Agent respone overtime')
bulk_data.append(data)
responeutils.bluk_insert(storage, no_response_agents, bulk_data, expire)
asyncrequest.status = manager_common.FINISH
if no_response_agents:
asyncrequest.resultcode = manager_common.RESULT_NOT_ALL_SUCCESS
asyncrequest.result = 'agents not respone, count:%d' % len(no_response_agents)
else:
asyncrequest.resultcode = manager_common.RESULT_SUCCESS
asyncrequest.result = 'all agent respone result'
session.flush()
if post_run:
try:
post_run.run(asyncrequest, no_response_agents)
except RpcServerCtxtException as e:
asyncrequest.result += (' ctxt post function error~%s' % e.message)
session.flush()
session.close()
threadpool.add_thread(safe_func_wrapper, check_respone, LOG)