async def go(): _, port, url = await self.create_server( 'GET', '/wot/certified-by/pubkey', handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(certified_by, 'pubkey') await client.close()
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) try: # Create Web Socket connection on block path (async method) ws = await client(bma.ws.block) # Type: WSConnection print("Connected successfully to web socket block path") loop = True # Iterate on each message received... while loop: print("Waiting message...") # Wait and capture next message data = await ws.receive_json() jsonschema.validate(data, bma.ws.WS_BLOCK_SCHEMA) print("Message received:") print(json.dumps(data, indent=2)) # Close session await client.close() except (aiohttp.WSServerHandshakeError, ValueError) as e: print("Websocket block {0} : {1}".format(type(e).__name__, str(e))) except (aiohttp.ClientError, gaierror, TimeoutError) as e: print("{0} : {1}".format(str(e), BMAS_ENDPOINT)) except jsonschema.ValidationError as e: print("{:}:{:}".format(str(e.__class__.__name__), str(e))) await client.close()
async def go(): _, port, url = await self.create_server('GET', '/wot/members', handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(members) await client.close()
async def go(): _, port, _ = await self.create_server("GET", "/blockchain/with/tx", handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(tx) await client.close()
async def main(): """ Main code (asynchronous requests) You can send one millions request with aiohttp : https://pawelmhm.github.io/asyncio/python/aiohttp/2016/04/22/asyncio-aiohttp.html But don't do that on one server, it's DDOS ! """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) tasks = [] # Get the node summary infos by dedicated method (with json schema validation) print("\nCall bma.node.summary:") task = asyncio.ensure_future(client(bma.node.summary)) tasks.append(task) # Get the money parameters located in the first block print("\nCall bma.blockchain.parameters:") task = asyncio.ensure_future(client(bma.blockchain.parameters)) tasks.append(task) responses = await asyncio.gather(*tasks) # you now have all response bodies in this variable print("\nResponses:") print(responses) # Close client aiohttp session await client.close()
async def main(): """ Main code (synchronous requests) """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos by dedicated method (with json schema validation) print("\nCall bma.node.summary:") response = await client(bma.node.summary) print(response) # Get the money parameters located in the first block print("\nCall bma.blockchain.parameters:") response = await client(bma.blockchain.parameters) print(response) # Get the current block print("\nCall bma.blockchain.current:") response = await client(bma.blockchain.current) print(response) # Get the block number 10 print("\nCall bma.blockchain.block(10):") response = await client(bma.blockchain.block, 10) print(response) # jsonschema validator summary_schema = { "type": "object", "properties": { "duniter": { "type": "object", "properties": { "software": { "type": "string" }, "version": { "type": "string" }, "forkWindowSize": { "type": "number" }, }, "required": ["software", "version"], } }, "required": ["duniter"], } # Get the node summary infos (direct REST GET request) print("\nCall direct get on node/summary") response = await client.get("node/summary", rtype=RESPONSE_AIOHTTP, schema=summary_schema) print(response) # Close client aiohttp session await client.close()
def heads(client: Client): """ GET Certification data over a member :param client: Client to connect to the api :rtype: dict """ return client.get(MODULE + '/ws2p/heads', schema=WS2P_HEADS_SCHEMA)
async def go(): _, port, _ = await self.create_server( "GET", "/wot/certifiers-of/pubkey", handler ) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(certifiers_of, "pubkey") await client.close()
async def go(): _, port, url = await self.create_server('GET', '/network/ws2p/heads', handler) with self.assertRaises(jsonschema.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(heads) await client.close()
async def go(): _, port, _ = await self.create_server("GET", "/network/peering/peers", handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(network.peers) await client.close()
def peer(client: Client) -> _WSRequestContextManager: """ Connect to peer websocket :param client: Client to connect to the api :return: """ return client.connect_ws(MODULE + '/peer')
def block(client: Client) -> _WSRequestContextManager: """ Connect to block websocket :param client: Client to connect to the api :return: """ return client.connect_ws(MODULE + '/block')
async def go(): _, port, url = await self.create_server('GET', '/blockchain/with/certs', handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(certifications) await client.close()
def heads(client: Client): """ GET Certification data over a member :param client: Client to connect to the api :rtype: dict """ return client.get(MODULE + "/ws2p/heads", schema=WS2P_HEADS_SCHEMA)
async def go(): _, port, url = await self.create_server( 'GET', '/blockchain/memberships' '/8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU', handler) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(memberships, "8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU") await client.close()
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos to test the connection response = await client(bma.node.summary) print(response) # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"Enter recipient pubkey: ") # capture current block to get version and currency and blockstamp current_block = await client(bma.blockchain.current) # capture sources of account response = await client(bma.tx.sources, pubkey_from) if len(response["sources"]) == 0: print("no sources found for account %s" % pubkey_to) sys.exit(1) # get the first source source = response["sources"][0] # create the transaction document transaction = get_transaction_document(current_block, source, pubkey_from, pubkey_to) # sign document transaction.sign([key]) # send the Transaction document to the node response = await client(bma.tx.process, transaction.signed_raw()) if response.status == 200: print(await response.text()) else: print("Error while publishing transaction: {0}".format( await response.text())) # Close client aiohttp session await client.close()
async def go(): _, port, _ = await self.create_server( "GET", "/blockchain/hardship/8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU", handler, ) with self.assertRaises(jsonschema.exceptions.ValidationError): client = Client(BMAEndpoint("127.0.0.1", "", "", port)) await client(hardship, "8Fi1VSTbjkXguwThF4v2ZxC5whK7pwG2vcGTkPUPjPGU") await client.close()
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos to test the connection response = await client(bma.node.summary) print(response) # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"Enter your public key: ") # init signer instance signer = SigningKey.from_credentials(salt, password) # check public key if signer.pubkey != pubkey: print("Bad credentials!") sys.exit(0) # capture current block to get currency name current_block = await client(bma.blockchain.current) # create our Identity document to sign the Certification document identity = await get_identity_document(client, current_block, pubkey) if identity is None: print("Identity not found for pubkey {0}".format(pubkey)) # Close client aiohttp session await client.close() sys.exit(1) # get the revoke document revocation_signed_raw_document = get_signed_raw_revocation_document( identity, salt, password) # save revoke document in a file fp = open(REVOCATION_DOCUMENT_FILE_PATH, "w") fp.write(revocation_signed_raw_document) fp.close() # document saved print("Revocation document saved in %s" % REVOCATION_DOCUMENT_FILE_PATH) # Close client aiohttp session await client.close()
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos to test the connection response = await client(bma.node.summary) print(response) # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"Enter certified pubkey: ") # capture current block to get version and currency and blockstamp current_block = await client(bma.blockchain.current) # create our Identity document to sign the Certification document identity = await get_identity_document(client, current_block, pubkey_to) if identity is None: print("Identity not found for pubkey {0}".format(pubkey_to)) # Close client aiohttp session await client.close() sys.exit(1) # send the Certification document to the node certification = get_certification_document(current_block, identity, pubkey_from) # sign document certification.sign([key]) # Here we request for the path wot/certify response = await client(bma.wot.certify, certification.signed_raw()) if response.status == 200: print(await response.text()) else: print("Error while publishing certification: {0}".format( await response.text())) # Close client aiohttp session await client.close()
async def recursive_discovering(endpoints, endpoint): """ Discover recursively new nodes. If new node found add it and try to found new node from his known nodes. """ api = generate_duniterpy_endpoint_format(endpoint) sub_client = Client(api) news = await get_peers_among_leaves(sub_client) await sub_client.close() for new in news: if best_endpoint_address(new, False) is not None and new not in endpoints: endpoints.append(new) await recursive_discovering(endpoints, new) return endpoints
async def generate_ws2p_endpoint( bma_endpoint: Union[str, BMAEndpoint, SecuredBMAEndpoint]) -> WS2PEndpoint: """ Retrieve WS2P endpoints from BMA peering Take the first one found """ bma_client = Client(bma_endpoint) peering = await bma_client(bma.network.peering) await bma_client.close() for endpoint in peering["endpoints"]: if endpoint.startswith("WS2P"): return WS2PEndpoint.from_inline(endpoint) raise ValueError("No WS2P endpoint found")
async def main(): """ Main code (synchronous requests) """ # Create Client from endpoint string in Duniter format client = Client(ES_CORE_ENDPOINT) # Get the current node (direct REST GET request) print("\nGET g1-test/block/current/_source:") response = await client.get('g1-test/block/current/_source') print(response) # Get the node number 2 with only selected fields (direct REST GET request) print("\nGET g1-test/block/2/_source:") response = await client.get( 'g1-test/block/2/_source', {'_source': 'number,hash,dividend,membersCount'}) print(response) # Close client aiohttp session await client.close() # Create Client from endpoint string in Duniter format client = Client(ES_USER_ENDPOINT) # prompt entry pubkey = input("\nEnter a public key to get the user profile: ") # Get the profil of a public key (direct REST GET request) print("\nGET user/profile/{0}/_source:".format(pubkey)) response = await client.get('user/profile/{0}/_source'.format( pubkey.strip(' \n'))) print(response) # Close client aiohttp session await client.close()
async def test_check_passed_blocks_range(from_block, to_block, capsys, monkeypatch): monkeypatch.setattr(bma.blockchain, "current", current) client = Client(EndPoint().BMA_ENDPOINT) # https://medium.com/python-pandemonium/testing-sys-exit-with-pytest-10c6e5f7726f with pytest.raises(SystemExit) as pytest_wrapped_e: await check_passed_blocks_range(client, from_block, to_block) assert pytest_wrapped_e.type == SystemExit assert pytest_wrapped_e.value.code == FAILURE_EXIT_STATUS captured = capsys.readouterr() if to_block == HEAD_BLOCK + 1: expected = "Passed TO_BLOCK argument is bigger than the head block: " + str( HEAD_BLOCK) else: expected = "TO_BLOCK should be bigger or equal to FROM_BLOCK\n" assert expected in captured.out
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) try: # Create Web Socket connection on block path ws_connection = client(bma.ws.block) # From the documentation ws_connection should be a ClientWebSocketResponse object... # # https://docs.aiohttp.org/en/stable/client_quickstart.html#websockets # # In reality, aiohttp.session.ws_connect() returns a aiohttp.client._WSRequestContextManager instance. # It must be used in a with statement to get the ClientWebSocketResponse instance from it (__aenter__). # At the end of the with statement, aiohttp.client._WSRequestContextManager.__aexit__ is called # and close the ClientWebSocketResponse in it. # Mandatory to get the "for msg in ws" to work ! async with ws_connection as ws: print("Connected successfully to web socket block path") # Iterate on each message received... async for msg in ws: # if message type is text... if msg.type == aiohttp.WSMsgType.TEXT: print("Received a block") # Validate jsonschema and return a the json dict block_data = parse_text(msg.data, bma.ws.WS_BLOCK_SCHEMA) print(block_data) elif msg.type == aiohttp.WSMsgType.CLOSED: # Connection is closed print("Web socket connection closed !") elif msg.type == aiohttp.WSMsgType.ERROR: # Connection error print("Web socket connection error !") # Close session await client.close() except (aiohttp.WSServerHandshakeError, ValueError) as e: print("Websocket block {0} : {1}".format(type(e).__name__, str(e))) except (aiohttp.ClientError, gaierror, TimeoutError) as e: print("{0} : {1}".format(str(e), BMAS_ENDPOINT)) except jsonschema.ValidationError as e: print("{:}:{:}".format(str(e.__class__.__name__), str(e)))
async def test_tx_history_generate_table(): client = Client("BMAS " + " ".join(G1_DEFAULT_ENDPOINT)) ud_value = 10.07 currency = "gtest" uids = False table_columns = 5 pubkey = "78ZwwgpgdH5uLZLbThUQH7LKwPgjMunYfLiCfUCySkM8" received_txs, sent_txs = list(), list() await tx_history.get_transactions_history(client, pubkey, received_txs, sent_txs) tx_history.remove_duplicate_txs(received_txs, sent_txs) txs_list = await tx_history.generate_table(received_txs, sent_txs, pubkey, ud_value, currency, uids) await client.close() for tx_list in txs_list: assert len(tx_list) == table_columns
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos by dedicated method (with json schema validation) response = await client(bma.node.summary) print(response) # capture current block to get version and currency and blockstamp current_block = await client(bma.blockchain.current) # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"results"][0] # create a membership demand document membership = get_membership_document("IN", current_block, identity, key) # send the membership signed raw document to the node response = await client(bma.blockchain.membership, membership.signed_raw()) if response.status == 200: print(await response.text()) else: print("Error while publishing membership : {0}".format( await response.text())) # Close client aiohttp session await client.close()
async def get_ws2p_endpoints( bma_endpoint: Union[str, BMAEndpoint, SecuredBMAEndpoint] ) -> List[WS2PEndpoint]: """ Return the list of WS2P endpoints for a BMA endpoint """ ws2p_endpoints = list() bma_client = Client(bma_endpoint) try: peering = await bma_client(bma.network.peering) except Exception as ex: await bma_client.close() raise ex for endpoint in peering["endpoints"]: if endpoint.startswith("WS2P"): ws2p_endpoints.append(WS2PEndpoint.from_inline(endpoint)) await bma_client.close() return ws2p_endpoints
async def verify_blocks_signatures(from_block, to_block): client = Client(EndPoint().BMA_ENDPOINT) to_block = await check_passed_blocks_range(client, from_block, to_block) invalid_blocks_signatures = list() chunks_from = range(from_block, to_block + 1, BMA_MAX_BLOCKS_CHUNK_SIZE) with progressbar(chunks_from, label="Processing blocks verification") as bar: for chunk_from in bar: chunk_size = get_chunk_size(from_block, to_block, chunks_from, chunk_from) logging.info("Processing chunk from block {} to {}".format( chunk_from, chunk_from + chunk_size)) chunk = await get_chunk(client, chunk_size, chunk_from) for block in chunk: block = Block.from_signed_raw(block["raw"] + block["signature"] + "\n") verify_block_signature(invalid_blocks_signatures, block) await client.close() display_result(from_block, to_block, invalid_blocks_signatures)
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos by dedicated method (with json schema validation) response = await client(bma.node.summary) print(response) # capture current block to get version and currency and blockstamp current_block = await client(bma.blockchain.current) # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"Enter your UID: ") # create our signed identity document identity = get_identity_document(current_block, uid, salt, password) # create a membership demand document membership = get_membership_document("IN", current_block, identity, salt, password) # send the membership signed raw document to the node response = await client(bma.blockchain.membership, membership.signed_raw()) if response.status == 200: print(await response.text()) else: print("Error while publishing membership : {0}".format(await response.text())) # Close client aiohttp session await client.close()
async def main(): """ Main code """ # Create Client from endpoint string in Duniter format client = Client(BMAS_ENDPOINT) # Get the node summary infos to test the connection response = await client(bma.node.summary) print(response) # capture current block to get version and currency and blockstamp current_block = await client(bma.blockchain.current) # prompt entry uid = input("Enter your Unique IDentifier (pseudonym): ") # prompt hidden user entry salt = getpass.getpass("Enter your passphrase (salt): ") # prompt hidden user entry password = getpass.getpass("Enter your password: "******"Error while publishing identity : {0}".format(await response.text())) # Close client aiohttp session await client.close()
def __init__(self): self.client = Client(EndPoint().BMA_ENDPOINT)