def DISABLED_test_defaults_valgrind(self):
""" Run valgrind over a simple SSL connection (no certificates)
"""
# the openssl libraries produce far too many valgrind errors to be
# useful. AFAIK, there is no way to wriate a valgrind suppression
# expression that will ignore all errors from a given library.
# Until we can, skip this test.
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverValgrind()
receiver.subscriptions = ["amqps://~127.0.0.1:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
receiver.start()
sender = common.MessengerSenderValgrind()
sender.targets = ["amqps://127.0.0.1:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(
sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(
receiver.cmdline())
def DISABLED_test_defaults_valgrind(self):
""" Run valgrind over a simple SSL connection (no certificates)
"""
# the openssl libraries produce far too many valgrind errors to be
# useful. AFAIK, there is no way to wriate a valgrind suppression
# expression that will ignore all errors from a given library.
# Until we can, skip this test.
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverValgrind()
receiver.subscriptions = ["amqps://~127.0.0.1:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
receiver.start()
sender = common.MessengerSenderValgrind()
sender.targets = ["amqps://127.0.0.1:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(receiver.cmdline())
def test_server_authentication_messenger_app(self):
""" Test an SSL authentication using the Messenger apps.
"""
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverC()
receiver.subscriptions = ["amqps://~0.0.0.0:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
# Note hack - by default we use the client-certificate for the
# _server_ because the client-certificate's common name field
# is "127.0.0.1", which will match the target address used by
# the sender.
receiver.certificate = self._testpath("client-certificate.pem")
receiver.privatekey = self._testpath("client-private-key.pem")
receiver.password = "******"
receiver.start()
sender = common.MessengerSenderC()
sender.targets = ["amqps://127.0.0.1:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.ca_db = self._testpath("ca-certificate.pem")
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(
sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(
receiver.cmdline())
def _do_oneway_test(self, receiver, sender, domain="amqp"):
""" Send N messages to a receiver.
Parameters:
iterations - repeat the senders this many times
target_count = # of targets to send to.
send_count = # messages sent to each target
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.timeout = MessengerTests._timeout
self.receivers.append(receiver)
sender.targets = [
"%s://0.0.0.0:%s/X%d" % (domain, port, j)
for j in range(target_count)
]
sender.send_count = send_total
sender.timeout = MessengerTests._timeout
self.senders.append(sender)
self._do_test(iterations)
def test_server_authentication_messenger_app(self):
""" Test an SSL authentication using the Messenger apps.
"""
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverC()
receiver.subscriptions = ["amqps://~0.0.0.0:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
# Note hack - by default we use the client-certificate for the
# _server_ because the client-certificate's common name field
# is "127.0.0.1", which will match the target address used by
# the sender.
receiver.certificate = self._testpath("client-certificate.pem")
receiver.privatekey = self._testpath("client-private-key.pem")
receiver.password = "******"
receiver.start()
sender = common.MessengerSenderC()
sender.targets = ["amqps://127.0.0.1:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.ca_db = self._testpath("ca-certificate.pem")
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(receiver.cmdline())
def _do_echo_test(self, receiver, sender, domain="amqp"):
""" Send N messages to a receiver, which responds to each.
Parameters:
iterations - repeat the senders this many times
target_count - # targets to send to
send_count = # messages sent to each target
send_batch - wait for replies after this many messages sent
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_batch = self.send_batch
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.send_reply = True
receiver.timeout = MessengerTests._timeout
self.receivers.append(receiver)
sender.targets = [
"%s://0.0.0.0:%s/%dY" % (domain, port, j)
for j in range(target_count)
]
sender.send_count = send_total
sender.get_reply = True
sender.send_batch = send_batch
sender.timeout = MessengerTests._timeout
self.senders.append(sender)
self._do_test(iterations)
def _do_echo_test(self, receiver, sender, domain="amqp"):
""" Send N messages to a receiver, which responds to each.
Parameters:
iterations - repeat the senders this many times
target_count - # targets to send to
send_count = # messages sent to each target
send_batch - wait for replies after this many messages sent
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_batch = self.send_batch
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.send_reply = True
receiver.timeout = MessengerTests._timeout
self.receivers.append( receiver )
sender.targets = ["%s://0.0.0.0:%s/%dY" % (domain, port, j) for j in range(target_count)]
sender.send_count = send_total
sender.get_reply = True
sender.send_batch = send_batch
sender.timeout = MessengerTests._timeout
self.senders.append( sender )
self._do_test(iterations)
def _do_oneway_test(self, receiver, sender, domain="amqp"):
""" Send N messages to a receiver.
Parameters:
iterations - repeat the senders this many times
target_count = # of targets to send to.
send_count = # messages sent to each target
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.timeout = MessengerTests._timeout
self.receivers.append( receiver )
sender.targets = ["%s://0.0.0.0:%s/X%d" % (domain, port, j) for j in range(target_count)]
sender.send_count = send_total
sender.timeout = MessengerTests._timeout
self.senders.append( sender )
self._do_test(iterations)
def _do_star_topology_test(self, r_factory, s_factory, domain="amqp"):
"""
A star-like topology, with a central receiver at the hub, and senders at
the spokes. Each sender will connect to each of the ports the receiver is
listening on. Each sender will then create N links per each connection.
Each sender will send X messages per link, waiting for a response.
Parameters:
iterations - repeat the senders this many times
port_count - # of ports the receiver will listen on. Each sender connects
to all ports.
sender_count - # of senders
target_count - # of targets per connection
send_count - # of messages sent to each target
send_batch - # of messages to send before waiting for response
"""
iterations = self.iterations
port_count = self.port_count
sender_count = self.sender_count
target_count = self.target_count
send_count = self.send_count
send_batch = self.send_batch
send_total = port_count * target_count * send_count
receive_total = send_total * sender_count * iterations
ports = free_tcp_ports(port_count)
receiver = r_factory()
receiver.subscriptions = [
"%s://~0.0.0.0:%s" % (domain, port) for port in ports
]
receiver.receive_count = receive_total
receiver.send_reply = True
receiver.timeout = MessengerTests._timeout
self.receivers.append(receiver)
for i in range(sender_count):
sender = s_factory()
sender.targets = [
"%s://0.0.0.0:%s/%d" % (domain, port, j) for port in ports
for j in range(target_count)
]
sender.send_count = send_total
sender.send_batch = send_batch
sender.get_reply = True
sender.timeout = MessengerTests._timeout
self.senders.append(sender)
self._do_test(iterations)
def _do_relay_test(self, receiver, relay, sender, domain="amqp"):
""" Send N messages to a receiver, which replies to each and forwards
each of them to different receiver.
Parameters:
iterations - repeat the senders this many times
target_count - # targets to send to
send_count = # messages sent to each target
send_batch - wait for replies after this many messages sent
forward_count - forward to this many targets
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_batch = self.send_batch
forward_count = self.forward_count
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.send_reply = True
# forward to 'relay' - uses two links
# ## THIS FAILS:
# receiver.forwards = ["amqp://Relay/%d" % j for j in range(forward_count)]
receiver.forwards = ["%s://Relay" % domain]
receiver.timeout = MessengerTests._timeout
self.receivers.append(receiver)
relay.subscriptions = ["%s://0.0.0.0:%s" % (domain, port)]
relay.name = "Relay"
relay.receive_count = receive_total
relay.timeout = MessengerTests._timeout
self.receivers.append(relay)
# send to 'receiver'
sender.targets = [
"%s://0.0.0.0:%s/X%dY" % (domain, port, j)
for j in range(target_count)
]
sender.send_count = send_total
sender.get_reply = True
sender.timeout = MessengerTests._timeout
self.senders.append(sender)
self._do_test(iterations)
def _do_relay_test(self, receiver, relay, sender, domain="amqp"):
""" Send N messages to a receiver, which replies to each and forwards
each of them to different receiver.
Parameters:
iterations - repeat the senders this many times
target_count - # targets to send to
send_count = # messages sent to each target
send_batch - wait for replies after this many messages sent
forward_count - forward to this many targets
"""
iterations = self.iterations
send_count = self.send_count
target_count = self.target_count
send_batch = self.send_batch
forward_count = self.forward_count
send_total = send_count * target_count
receive_total = send_total * iterations
port = free_tcp_ports()[0]
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port)]
receiver.receive_count = receive_total
receiver.send_reply = True
# forward to 'relay' - uses two links
# ## THIS FAILS:
# receiver.forwards = ["amqp://Relay/%d" % j for j in range(forward_count)]
receiver.forwards = ["%s://Relay" % domain]
receiver.timeout = MessengerTests._timeout
self.receivers.append( receiver )
relay.subscriptions = ["%s://0.0.0.0:%s" % (domain, port)]
relay.name = "Relay"
relay.receive_count = receive_total
relay.timeout = MessengerTests._timeout
self.receivers.append( relay )
# send to 'receiver'
sender.targets = ["%s://0.0.0.0:%s/X%dY" % (domain, port, j) for j in range(target_count)]
sender.send_count = send_total
sender.get_reply = True
sender.timeout = MessengerTests._timeout
self.senders.append( sender )
self._do_test(iterations)
def _do_star_topology_test(self, r_factory, s_factory, domain="amqp"):
"""
A star-like topology, with a central receiver at the hub, and senders at
the spokes. Each sender will connect to each of the ports the receiver is
listening on. Each sender will then create N links per each connection.
Each sender will send X messages per link, waiting for a response.
Parameters:
iterations - repeat the senders this many times
port_count - # of ports the receiver will listen on. Each sender connects
to all ports.
sender_count - # of senders
target_count - # of targets per connection
send_count - # of messages sent to each target
send_batch - # of messages to send before waiting for response
"""
iterations = self.iterations
port_count = self.port_count
sender_count = self.sender_count
target_count = self.target_count
send_count = self.send_count
send_batch = self.send_batch
send_total = port_count * target_count * send_count
receive_total = send_total * sender_count * iterations
ports = free_tcp_ports(port_count)
receiver = r_factory()
receiver.subscriptions = ["%s://~0.0.0.0:%s" % (domain, port) for port in ports]
receiver.receive_count = receive_total
receiver.send_reply = True
receiver.timeout = MessengerTests._timeout
self.receivers.append( receiver )
for i in range(sender_count):
sender = s_factory()
sender.targets = ["%s://0.0.0.0:%s/%d" % (domain, port, j) for port in ports for j in range(target_count)]
sender.send_count = send_total
sender.send_batch = send_batch
sender.get_reply = True
sender.timeout = MessengerTests._timeout
self.senders.append( sender )
self._do_test(iterations)
def test_defaults_messenger_app(self):
""" Test an SSL connection using the Messenger apps (no certificates)
"""
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverC()
receiver.subscriptions = ["amqps://~0.0.0.0:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
receiver.start()
sender = common.MessengerSenderC()
sender.targets = ["amqps://0.0.0.0:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(receiver.cmdline())
def test_defaults_messenger_app(self):
""" Test an SSL connection using the Messenger apps (no certificates)
"""
port = common.free_tcp_ports()[0]
receiver = common.MessengerReceiverC()
receiver.subscriptions = ["amqps://~0.0.0.0:%s" % port]
receiver.receive_count = 1
receiver.timeout = self.timeout
receiver.start()
sender = common.MessengerSenderC()
sender.targets = ["amqps://0.0.0.0:%s/X" % port]
sender.send_count = 1
sender.timeout = self.timeout
sender.start()
sender.wait()
assert sender.status() == 0, "Command '%s' failed" % str(sender.cmdline())
receiver.wait()
assert receiver.status() == 0, "Command '%s' failed" % str(receiver.cmdline())
