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)