def test_web_api_forward(self):
# Test _msgforward
local_node = self._create_node(8807)
gossip = Gossip(local_node)
path = tempfile.mkdtemp()
ledger = Journal(gossip, data_directory=path, genesis_ledger=True)
# Create peers for the message to be forwarded to
node1 = self._create_node(8881)
node2 = self._create_node(8882)
node1.is_peer = True
node2.is_peer = True
gossip.add_node(node1)
gossip.add_node(node2)
validator = TestValidator(ledger)
forward_page = ForwardPage(validator)
# Create message to use and the data to forward
msg = shutdown_message.ShutdownMessage()
msg.sign_from_node(local_node)
data = msg.dump()
# Post /forward
request = self._create_post_request("forward", data)
r = yaml.load(forward_page.do_post(request))
self.assertEquals(r, data)
self.assertIn(msg.Identifier, node1.MessageQ.Messages)
self.assertIn(msg.Identifier, node2.MessageQ.Messages)
def test_web_api_forward(self):
# Test _msgforward
validator = self._create_validator()
# Create peers for the message to be forwarded to
node1 = self._create_node(8881)
node2 = self._create_node(8882)
node1.is_peer = True
node2.is_peer = True
validator.gossip.add_node(node1)
validator.gossip.add_node(node2)
forward_page = ForwardPage(validator)
# Create message to use and the data to forward
msg = shutdown_message.ShutdownMessage()
msg.sign_from_node(validator.gossip.LocalNode)
data = msg.dump()
# Post /forward
request = self._create_post_request("forward", data)
r = yaml.load(forward_page.do_post(request))
self.assertEquals(r, data)
self.assertIn(msg.Identifier, node1.MessageQ.Messages)
self.assertIn(msg.Identifier, node2.MessageQ.Messages)
# Create an unknown error message to use
msg = ErrorMessage({'error': "an unknown error message"})
msg.sign_from_node(validator.gossip.LocalNode)
data = msg.dump()
# Post an unknown error messsage
request = self._create_post_request("forward", data)
r = yaml.load(forward_page.do_post(request))
self.assertEquals(r['status'], http.NOT_FOUND)
def do_shutdown(self, args):
"""
shutdown -- Command to send a shutdown message to the validator pool
"""
self.sign_and_post(shutdown_message.ShutdownMessage({}))
return True
def test_gossip_get_message_handler(self):
# Get message handler from MessageHandlerMap
# Will throw error if not in HandlerMap
core = self._setup(8841)
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
handler = core.dispatcher.get_message_handler(msg)
self.assertEqual(handler, shutdown_message.shutdown_handler)
def test_gossip_datagram_received(self):
# Test that datagramReceived behaves as expected
core = self._setup(9500)
peer = self._create_node(9501)
peer2 = self._create_node(9502)
core.add_node(peer)
core.add_node(peer2)
msg = self._create_msg()
pak = Packet()
pak.add_message(msg, peer, peer2, 0)
data = pak.pack()
# Test correct use of datagramReceived
core.datagramReceived(data, "localhost:9001")
msgType = core.MessageStats.get_stats(["MessageType"])
self.assertIn('/gossip.Message/MessageBase', msgType["MessageType"])
pakStats = core.PacketStats.get_stats(["MessagesAcked"])
self.assertEqual(pakStats["MessagesAcked"], 1)
# Test handling of duplicate packets
msg2 = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
core.MessageHandledMap[msg2.Identifier] = time.time()
pak.add_message(msg2, peer, peer2, 1)
data2 = pak.pack()
core.datagramReceived(data2, "localhost:9001")
pakStats = core.PacketStats.get_stats(["DuplicatePackets"])
self.assertEqual(pakStats["DuplicatePackets"], 1)
def test_gossip_unpack_message(self):
# Test unpacking message using its handler
core = self._setup(8842)
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
info = msg.dump()
m = core.dispatcher.unpack_message(
'/gossip.messages.ShutdownMessage/ShutdownMessage', info)
self.assertEqual(msg.Identifier, m.Identifier)
def test_gossip_dispatcher(self):
# Test _dispatch will not loop if not processing messages
core = self._setup(8883)
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
core.IncomingMessageQueue.appendleft(msg)
# Should not run if ProcessIncomingMessages is False
# Otherwise it will loop
core.ProcessIncomingMessages = False
core._dispatcher()
def post_shutdown(self):
client = SawtoothClient(self.url)
msg = shutdown_message.ShutdownMessage({})
msg.SenderID = self._admin_node.Address
msg.sign_from_node(self._admin_node)
try:
client.forward_message(msg)
except MessageException as me:
print(me)
def post_shutdown(self):
lwc = LedgerWebClient(self.url)
msg = shutdown_message.ShutdownMessage({})
msg.SenderID = self._admin_node.Address
msg.sign_from_node(self._admin_node)
try:
lwc.post_message(msg)
except MessageException as me:
print me
def post_shutdown(self):
lwc = ledger_web_client.LedgerWebClient(self.Url)
msg = shutdown_message.ShutdownMessage({})
msg.SenderID = self.AdminNode.Address
msg.sign_from_node(self.AdminNode)
try:
lwc.post_message(msg)
except ledger_web_client.MessageException as me:
print me
def test_gossip_register_message_handlers(self):
# Test that a message handler and type can be added and removed
core = self._setup(8840)
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
# Remove ShutdownMessage handler
core.clear_message_handler(msg)
self.assertNotIn("/gossip.messages.ShutdownMessage/ShutdownMessage",
core.MessageHandlerMap)
# Add ShutdownMessage handler
core.register_message_handler(msg, shutdown_message.shutdown_handler)
self.assertIn("/gossip.messages.ShutdownMessage/ShutdownMessage",
core.MessageHandlerMap)
def test_web_api_msg_echo(self):
# Test _msgecho
LocalNode = self._create_node(8805)
path = tempfile.mkdtemp()
ledger = Journal(LocalNode, DataDirectory=path, GenesisLedger=True)
validator = TestValidator(ledger)
root = RootPage(validator)
# Create message to use and the data to echo
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
msg.sign_from_node(LocalNode)
data = msg.dump()
# POST /echo
request = self._create_post_request("/echo", data)
self.assertEquals(yaml.load(root.do_post(request)), data)
def test_gossip_register_message_handlers(self):
# Test that a message handler and type can be added and removed
core = self._setup(8840)
msg = shutdown_message.ShutdownMessage({'__SIGNATURE__': "test"})
# Remove ShutdownMessage handler
core.dispatcher.clear_message_handler(msg)
self.assertFalse(
core.dispatcher.has_message_handler(
"/gossip.messages.ShutdownMessage/ShutdownMessage"))
# Add ShutdownMessage handler
core.dispatcher.register_message_handler(
msg, shutdown_message.shutdown_handler)
self.assertTrue(
core.dispatcher.has_message_handler(
"/gossip.messages.ShutdownMessage/ShutdownMessage"))
def test_web_api_msg_initiate(self):
# Test _msginitiate
LocalNode = self._create_node(8806)
path = tempfile.mkdtemp()
ledger = Journal(LocalNode, DataDirectory=path, GenesisLedger=True)
validator = TestValidator(ledger)
root = RootPage(validator)
# Create message to use and the data to initiate
msg = shutdown_message.ShutdownMessage()
data = msg.dump()
request = self._create_post_request("/initiate", data)
r = root.do_post(request)
self.assertEquals(r, "error processing http request /initiate\n")
request.client = address.IPv4Address("TCP", '127.0.0.1', 8806)
# Post /initiate - This should sign the message
r = yaml.load(root.do_post(request))
sig = r["__SIGNATURE__"]
r.pop("__SIGNATURE__", None)
data.pop("__SIGNATURE__", None)
self.assertEquals(r, data)
self.assertIsNotNone(sig)
def test_web_api_forward(self):
# Test _msgforward
LocalNode = self._create_node(8807)
path = tempfile.mkdtemp()
ledger = Journal(LocalNode, DataDirectory=path, GenesisLedger=True)
# Create peers for the message to be forwarded to
node1 = self._create_node(8881)
node2 = self._create_node(8882)
node1.is_peer = True
node2.is_peer = True
ledger.add_node(node1)
ledger.add_node(node2)
validator = TestValidator(ledger)
root = RootPage(validator)
# Create message to use and the data to forward
msg = shutdown_message.ShutdownMessage()
msg.sign_from_node(LocalNode)
data = msg.dump()
# Post /forward
request = self._create_post_request("forward", data)
r = yaml.load(root.do_post(request))
self.assertEquals(r, data)
self.assertIn(msg.Identifier, node1.MessageQ.Messages)
self.assertIn(msg.Identifier, node2.MessageQ.Messages)
