def __init__(self, client_id, transport, target, timeout, is_cast,
wait_after_msg):
client = rpc.RPCClient(transport, target).prepare(timeout=timeout)
method = _rpc_cast if is_cast else _rpc_call
super(RPCClient, self).__init__(client_id, client, method, not is_cast,
wait_after_msg)
def setup_clients(rabbit_url, num_clients):
clients = []
target = messaging.Target()
for i in range(num_clients):
transport = messaging.get_transport(cfg.CONF, url=rabbit_url)
client = rpc.RPCClient(transport, target)
clients.append(client)
global CLIENTS
CLIENTS = collections.deque(clients)
def send_msg(_id, transport, target, messages, wait_after_msg, timeout,
is_cast):
client = rpc.RPCClient(transport, target)
client = client.prepare(timeout=timeout)
rpc_method = _rpc_cast if is_cast else _rpc_call
for i in range(0, messages):
msg = "test message %d" % i
LOG.info("SEND: %s" % msg)
rpc_method(client, msg)
if wait_after_msg > 0:
time.sleep(wait_after_msg)
def __init__(self, transport, target, timeout, method, wait_after_msg):
self.client = rpc.RPCClient(transport, target)
self.client.prepare(timeout=timeout)
self.method = method
self.bytes = 0
self.msg_sent = 0
self.messages_count = len(MESSAGES)
# Start sending the messages from a random position to avoid
# memory re-usage and generate more realistic load on the library
# and a message transport
self.position = random.randint(0, self.messages_count - 1)
self.wait_after_msg = wait_after_msg
def rpc_call(_id, transport, messages, wait_after_msg, timeout):
target = messaging.Target(topic='t1', server='moi')
c = rpc.RPCClient(transport, target)
c = c.prepare(timeout=timeout)
for i in range(0, messages):
payload = "test %d" % i
LOG.info("SEND: %s" % payload)
try:
res = c.call({}, 'info', message=payload)
except Exception:
LOG.exception('no RCV for %s' % i)
else:
LOG.info("RCV: %s" % res)
if wait_after_msg > 0:
time.sleep(wait_after_msg)
def __init__(self, client_id, transport, target, timeout, is_cast,
wait_after_msg, sync_mode=False):
client = rpc.RPCClient(transport, target)
method = _rpc_cast if is_cast else _rpc_call
super(RPCClient, self).__init__(client_id,
client.prepare(timeout=timeout),
method,
not is_cast, wait_after_msg)
self.sync_mode = sync_mode
self.is_sync = False
# prepare the sync client
if sync_mode:
if sync_mode == 'call':
self.sync_client = self.client
else:
self.sync_client = client.prepare(fanout=True, timeout=timeout)
def send_msg(_id, transport, target, messages, wait_after_msg, timeout,
is_cast):
client = rpc.RPCClient(transport, target)
client = client.prepare(timeout=timeout)
rpc_method = _rpc_cast if is_cast else _rpc_call
ranges = RANDOM_VARIABLE.rvs(size=messages)
i = 0
for range_start in ranges:
length = random.randint(range_start, range_start + 497)
msg = ''.join(random.choice(string.lowercase) for x in range(length)) \
+ ' ' + str(i)
i += 1
# temporary file to log approximate bytes size of messages
with open('./oslo_%s_%s.log' % (target.topic, CURRENT_PID), 'a+') as f:
# 37 additional bytes for Python String object size canculation.
# In fact we may ignore these bytes, and estimate the data flow
# via number of symbols
f.write(str(length + 37) + '\n')
rpc_method(client, msg)
if wait_after_msg > 0:
time.sleep(wait_after_msg)
def __init__(self, transport):
client_target = target.Target('murano', 'tasks')
self._client = rpc.RPCClient(transport, client_target, timeout=15)
