def test_batch(self): gen_id = iter(range(100)) batch = ( Request('vadd.test', 5, 10, id_generator=gen_id), Request('vsub.test', arg1=10, arg2=9, id_generator=gen_id), Request('test.hello', 'WORLD', id_generator=gen_id), Request('nonexistent_method', id_generator=gen_id), Request('test.test_div', 10, 0, id_generator=gen_id), ) resp = self.client.send(batch) self.assertEqual(len(resp.data), 5) for r in resp.data: if r.id == 0: self.assertEqual(r.result, 15) elif r.id == 1: self.assertEqual(r.result, 1) elif r.id == 2: self.assertEqual(r.result, 'Hello WORLD!') elif r.id == 3: self.assertFalse(r.ok) self.assertEqual(r.code, -32601) elif r.id == 4: self.assertFalse(r.ok) self.assertEqual(r.code, -32000) self.assertEqual(r.message, 'division by zero')
def EpochTest(self, epoch: int) -> None: """Test epoch commands""" delay = 3 self._send_json(str(Request(f"setEpoch", epoch))) self.ExpectOk() time.sleep(delay) self._send_json(str(Request("getEpoch"))) self.ExpectRange("epoch", epoch + delay - 1, epoch + delay + 1)
def _get_rcp_request(self, path, **kwargs): kwargs['data'] = kwargs.get('data', None) rcp_request = Request(path) if kwargs['data']: rcp_request.update(params=kwargs['data']) return rcp_request
async def main(): response = await client.send( [Request("ping"), Notification("ping"), Request("ping")]) for data in response.data: if data.ok: print("{}: {}".format(data.id, data.result)) else: logging.error("%d: %s", data.id, data.message)
async def main(): async with websockets.connect("ws://localhost:5000") as ws: requests = [Request("ping"), Notification("ping"), Request("ping")] response = await WebSocketsClient(ws).send(requests) for data in response.data: if data.ok: print("{}: {}".format(data.id, data.result)) else: logging.error("%d: %s", data.id, data.message)
async def main(loop): async with aiohttp.ClientSession(loop=loop) as session: client = AiohttpClient(session, "http://localhost:5000") requests = [Request("ping"), Notification("ping"), Request("ping")] response = await client.send(requests) for data in response.data: if data.ok: print("{}: {}".format(data.id, data.result)) else: logging.error("%d: %s", data.id, data.message)
def _create_jsonrpc_params(self, method: RestMethod, params: Optional[NamedTuple]): # 'vars(namedtuple)' does not working in Python 3.7.4 # noinspection PyProtectedMember params = params._asdict() if params else None if params: params = {k: v for k, v in params.items() if v is not None} if "from_" in params: params["from"] = params.pop("from_") return Request(method.value.name, **params) if params else Request( method.value.name)
def get_regualr_key(self, address: str, block_number: Union[int, None]): payload = Request("chain_getRegularKey", address=address, blockNumber=block_number) response = self.client.send(payload) return response.result
def get_balance(self, address: str, block_number: Union[int, None]): payload = Request("chain_getBalance", address=address, blockNumber=block_number) response = self.client.send(payload) return response.result
def main(context: click.core.Context, method: str, request_type: str, id: Any, send: str) -> None: """ Create a JSON-RPC request. """ exit_status = 0 # Extract the jsonrpc arguments positional = [a for a in context.args if "=" not in a] named = { a.split("=")[0]: a.split("=")[1] for a in context.args if "=" in a } # Create the request if request_type == "notify": req = Notification(method, *positional, **named) else: req = Request(method, *positional, request_id=id, **named) # type: ignore # Sending? if send: client = HTTPClient(send) try: response = client.send(req) except JsonRpcClientError as e: click.echo(str(e), err=True) exit_status = 1 else: click.echo(response.text) # Otherwise, simply output the JSON-RPC request. else: click.echo(str(req)) sys.exit(exit_status)
def test_positional(self): assert Request("sqrt", 1) == { "jsonrpc": "2.0", "method": "sqrt", "params": [1], "id": 1, }
def __check_connection(self): url = "%s://%s:%s/jsonrpc" % (self.config.protocol, self.config.host, self.config.port) self.client = HTTPClient(url) self.client.session.auth = (self.config.username, self.config.passwd) response = self.client.send(Request('Application.GetProperties', list(), id_generator=id_generators.random())) if not response.data.ok: raise KodiServerCheckException()
def clean_current_playlist(self): response = self.client.send( Request('Playlist.Clear', self.playlist_id, id_generator=id_generators.random())) if response.data.ok: logger.info('Current playlist has cleaned') else: raise KodiActionException('Playlist.Clean')
async def test_send_exception_check_parameters(self): ws = MockWebSocket() ws.send = AsyncMock() expected_method = "fake_method" expected_exc = RuntimeError("test") expected_error_code = message_code.Response.fail_subscribe_limit expected_request = Request(method=expected_method, error=str(expected_exc), code=expected_error_code) expected_called_params = dict(expected_request) await WSDispatcher.send_exception(ws, method=expected_method, exception=expected_exc, error_code=expected_error_code) actual_called_params, _ = ws.send.call_args actual_called_params: dict = json.loads(actual_called_params[0]) # Remove id because jsonrpc call auto-increments request id. expected_called_params.pop("id") actual_called_params.pop("id") assert actual_called_params == expected_called_params
def execute_transaction(self, transaction, sender: str): payload = Request("chain_executeTransaction", transaction=transaction, sender=sender) response = self.client.send(payload) return response.result
def test_keyword(self): assert Request("find", name="Foo") == { "jsonrpc": "2.0", "method": "find", "params": {"name": "Foo"}, "id": 1, }
def __call__(self, *args, **argsn): if argsn: raise ValueError('json rpc 2 only supports array arguments') from jsonrpcclient.requests import Request request = Request(self.method, *args) response = self.client.send(request, timeout=self.timeout) return response.data.result
def get_pending_transactions( self, tx_from: Union[int, None], tx_to: Union[int, None] ): payload = Request("mempool_getPendingTransactions", tx_from, tx_to) response = self.client.send(payload) return response.data.result
def get_shard_users(self, shard_id: int, block_number: Union[int, None]): payload = Request("chain_getShardUsers", shardId=shard_id, blockNumber=block_number) response = self.client.send(payload) return response.result
async def publish_new_block(ws, channel_name, height, peer_id): call_method = WSDispatcher.PUBLISH_NEW_BLOCK channel_stub = get_channel_stub_by_channel_name(channel_name) try: while True: new_block_dumped, confirm_info_bytes = await channel_stub.async_task( ).announce_new_block(subscriber_block_height=height, subscriber_id=peer_id) new_block: dict = json.loads(new_block_dumped) if "error" in new_block: Logger.error( f"announce_new_block error: {new_block}, to citizen({peer_id})" ) break confirm_info = confirm_info_bytes.decode('utf-8') request = Request(call_method, block=new_block, confirm_info=confirm_info) Logger.debug(f"{call_method}: {request}") await ws.send(json.dumps(request)) height += 1 except exceptions.ConnectionClosed: Logger.debug( "Connection Closed by child.") # TODO: Useful message needed. except Exception as e: traceback.print_exc() # TODO: Keep this tb? await WSDispatcher.send_exception( ws, call_method, exception=e, error_code=message_code.Response.fail_announce_block)
def run_test(self): # generate block with many transactions parent_hash = self.rpc.block_by_epoch("latest_mined")['hash'] start_nonce = self.rpc.get_nonce(self.rpc.GENESIS_ADDR) txs = [self.rpc.new_tx(nonce=start_nonce + ii) for ii in range(0, 100)] hash = self.rpc.generate_custom_block(parent_hash=parent_hash, referee=[], txs=txs) epoch = self.rpc.block_by_hash(hash)["epochNumber"] # make sure block is executed self.rpc.generate_empty_blocks(5) # getting epoch receipts should result in error try: resp = block_on( self.ws.send(Request("cfx_getEpochReceipts", epoch))) assert False, "cfx_getEpochReceipts request should have failed" except ReceivedErrorResponseError as e: self.log.info(e.response) assert e.response.data.startswith("\"Oversized payload") except Exception as e: assert False, f"unexpected error: {e}" # this should succeed # resp = self.rpc.node.cfx_getEpochReceipts(epoch) self.log.info("Pass")
def get_text(self, transaction_hash: str, block_number: Union[int, None]): payload = Request("chain_getText", transactionHash=transaction_hash, blockNumber=block_number) response = self.client.send(payload) return response.result
def do_rpc(method, log_error=True, **kwargs): req = Request(method, **kwargs) try: url = AppInstance.settings.rpc_url() resp = post(url, json=req, timeout=10) if resp.status_code != 200 and log_error: logging.error("RPC ==> {}".format(req)) logging.error("RPC <== {}".format(resp.text)) if resp.status_code != 200: try: #Attempt parse response when failed return json.loads(resp.text) except: return None return json.loads(resp.text)["result"] except TimeoutError: if log_error: #Any RPC timeout errors are totally fatal logging.error("RPC Timeout") AppInstance.on_exit() show_error("RPC Timeout", "Timeout contacting RPC") exit(-1) return None else: return None except Exception as ex: logging.error(ex) return None
def unlock(self, account, passphrase): payload = Request("account_unlock", account=account, passphrase=passphrase) response = self.client.send(payload) return response.result
def import_raw(self, secret, passphrase): if isinstance(secret, bytes): secret = "0x" + binascii.hexlify(secret).decode("ascii") payload = Request("account_importRaw", secret, passphrase) response = self.client.send(payload) return response.data.result
def import_raw(self, secret, passphrase): payload = Request("account_importRaw", secret=secret, passphrase=passphrase) response = self.client.send(payload) return response.result
def fetch_data_packet(socket, device_addr, timestamp): req = Request("get_data_packet", timestamp=timestamp, device_addr_index=device_addr) print(f"{device_addr} -> {req}") socket.send_string(str(req)) resp = socket.recv().decode("utf-8") print(f"Response -> {resp}")
def get_regualr_key_owner(self, public_key: str, block_number: Union[int, None]): payload = Request("chain_getRegularKeyOwner", publicKey=public_key, blockNumber=block_number) response = self.client.send(payload) return response.result
def sign(self, message, account, passphrase): payload = Request("account_sign", message=message, account=account, passphrase=passphrase) response = self.client.send(payload) return response.result
def test_send_message_conn_error(self): client = ZeroMQClient("tcp://localhost:5555") # Set timeouts client.socket.setsockopt(zmq.RCVTIMEO, 5) client.socket.setsockopt(zmq.SNDTIMEO, 5) client.socket.setsockopt(zmq.LINGER, 5) with pytest.raises(zmq.error.ZMQError): client.send_message(str(Request("go")), response_expected=True)