def test_secure_sec_cannot_connect_returns_none(self):
authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
w = Wallet()
w2 = Wallet()
authenticator.add_verifying_key(w.verifying_key)
authenticator.add_verifying_key(w2.verifying_key)
authenticator.configure()
async def get():
r = await router.secure_send(msg={'hello': 'there'},
service='something',
wallet=w2,
vk=w.verifying_key,
ip='tcp://x',
ctx=self.ctx)
return r
loop = asyncio.get_event_loop()
res = loop.run_until_complete(get())
self.assertEqual(res, None)
authenticator.authenticator.stop()
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
asyncio.set_event_loop(self.loop)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(driver=self.driver), ctx=self.ctx)
def test_multicast_sends_to_multiple(self):
authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
w1 = Wallet()
w2 = Wallet()
w3 = Wallet()
authenticator.add_verifying_key(w1.verifying_key)
authenticator.add_verifying_key(w2.verifying_key)
authenticator.add_verifying_key(w3.verifying_key)
authenticator.configure()
m1 = router.Router(socket_id='tcp://127.0.0.1:10000',
ctx=self.ctx,
linger=2000,
poll_timeout=50,
secure=True,
wallet=w1)
q1 = router.QueueProcessor()
m1.add_service('something', q1)
m2 = router.Router(socket_id='tcp://127.0.0.1:10001',
ctx=self.ctx,
linger=2000,
poll_timeout=50,
secure=True,
wallet=w2)
q2 = router.QueueProcessor()
m2.add_service('something', q2)
async def get():
peers = {
w1.verifying_key: 'tcp://127.0.0.1:10000',
w2.verifying_key: 'tcp://127.0.0.1:10001'
}
await router.secure_multicast(msg={'hello': 'there'},
service='something',
wallet=w3,
peer_map=peers,
ctx=self.ctx)
tasks = asyncio.gather(
m1.serve(),
m2.serve(),
get(),
stop_server(m1, 1),
stop_server(m2, 1),
)
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
self.assertEqual(q1.q[0], {'hello': 'there'})
self.assertEqual(q2.q[0], {'hello': 'there'})
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
self.b = masternode.BlockService(blocks=storage.BlockStorage(),
driver=ContractDriver())
self.r = router.Router(socket_id='tcp://127.0.0.1:18001', ctx=self.ctx)
self.r.add_service(base.BLOCK_SERVICE, self.b)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.blocks = storage.BlockStorage()
self.driver = ContractDriver(driver=InMemDriver())
self.b = masternode.BlockService(blocks=self.blocks,
driver=self.driver)
self.blocks.drop_collections()
self.driver.flush()
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
def test_secure_request_returns_result(self):
authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
w = Wallet()
w2 = Wallet()
authenticator.add_verifying_key(w.verifying_key)
authenticator.add_verifying_key(w2.verifying_key)
authenticator.configure()
class MockProcessor(router.Processor):
async def process_message(self, msg):
return {'whats': 'good'}
m = router.Router(socket_id='tcp://127.0.0.1:10000',
ctx=self.ctx,
linger=2000,
poll_timeout=50,
secure=True,
wallet=w)
m.add_service('something', MockProcessor())
async def get():
r = await router.secure_request(msg={'hello': 'there'},
service='something',
wallet=w2,
vk=w.verifying_key,
ip='tcp://127.0.0.1:10000',
ctx=self.ctx)
return r
tasks = asyncio.gather(
m.serve(),
get(),
stop_server(m, 1),
)
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertDictEqual(res[1], {'whats': 'good'})
authenticator.authenticator.stop()
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.base_tcp = 'tcp://127.0.0.1:19000'
self.base_wallet = Wallet()
self.router = Router(socket_id=self.base_tcp,
ctx=self.ctx,
wallet=self.base_wallet,
secure=True)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
self.authenticator.add_verifying_key(self.base_wallet.verifying_key)
self.authenticator.configure()
def test_secure_request_sends_as_service(self):
authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
w = Wallet()
w2 = Wallet()
authenticator.add_verifying_key(w.verifying_key)
authenticator.add_verifying_key(w2.verifying_key)
authenticator.configure()
m = router.JSONAsyncInbox(socket_id='tcp://127.0.0.1:10000',
ctx=self.ctx,
linger=2000,
poll_timeout=50,
secure=True,
wallet=w)
async def get():
r = await router.secure_request(msg={'hello': 'there'},
service='something',
wallet=w2,
vk=w.verifying_key,
ip='tcp://127.0.0.1:10000',
ctx=self.ctx)
return r
tasks = asyncio.gather(
m.serve(),
get(),
stop_server(m, 1),
)
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertDictEqual(res[1], {
'service': 'something',
'msg': {
'hello': 'there'
}
})
def test_secure_send_receives_messages(self):
authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
w = Wallet()
w2 = Wallet()
authenticator.add_verifying_key(w.verifying_key)
authenticator.add_verifying_key(w2.verifying_key)
authenticator.configure()
m = router.Router(socket_id='tcp://127.0.0.1:10000',
ctx=self.ctx,
linger=2000,
poll_timeout=50,
secure=True,
wallet=w)
q = router.QueueProcessor()
m.add_service('something', q)
async def get():
await router.secure_send(msg={'hello': 'there'},
service='something',
wallet=w2,
vk=w.verifying_key,
ip='tcp://127.0.0.1:10000',
ctx=self.ctx)
tasks = asyncio.gather(
m.serve(),
get(),
stop_server(m, 1),
)
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
self.assertEqual(q.q[0], {'hello': 'there'})
authenticator.authenticator.stop()
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
bootnodes={},
blocks=storage.BlockStorage(),
driver=ContractDriver(),
debug=True,
store=False,
seed=None,
bypass_catchup=False,
node_type=None,
genesis_path=lamden.contracts.__path__[0],
reward_manager=rewards.RewardManager(),
nonces=storage.NonceStorage()):
self.driver = driver
self.nonces = nonces
self.store = store
self.seed = seed
self.blocks = blocks
self.event_writer = EventWriter()
self.log = get_logger('Base')
self.log.propagate = debug
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.genesis_path = genesis_path
self.client = ContractingClient(driver=self.driver,
submission_filename=genesis_path +
'/submission.s.py')
self.bootnodes = bootnodes
self.constitution = constitution
self.seed_genesis_contracts()
self.socket_authenticator = authentication.SocketAuthenticator(
bootnodes=self.bootnodes, ctx=self.ctx, client=self.client)
self.upgrade_manager = upgrade.UpgradeManager(client=self.client,
wallet=self.wallet,
node_type=node_type)
self.router = router.Router(socket_id=socket_base,
ctx=self.ctx,
wallet=wallet,
secure=True)
self.network = network.Network(wallet=wallet,
ip_string=socket_base,
ctx=self.ctx,
router=self.router)
self.new_block_processor = NewBlock(driver=self.driver)
self.router.add_service(
NEW_BLOCK_SERVICE,
self.new_block_processor) # Add this after catch up?
self.running = False
self.upgrade = False
self.reward_manager = reward_manager
self.current_height = storage.get_latest_block_height(self.driver)
self.current_hash = storage.get_latest_block_hash(self.driver)
self.bypass_catchup = bypass_catchup