def run(self):
exit_code = 0
sender_command = [
"quiver-arrow", "send", self.url, "--impl", self.sender_impl,
"--verbose"
]
sender_command += self.sender_options
receiver_command = [
"quiver-arrow", "receive", self.url, "--impl", self.receiver_impl,
"--verbose"
]
receiver_command += self.receiver_options
senders = list()
receivers = list()
for i in range(self.receiver_count):
receiver = _plano.start_process(receiver_command)
receivers.append(receiver)
_plano.wait_for_port(self.port)
for i in range(self.sender_count):
sender = _plano.start_process(sender_command)
senders.append(sender)
try:
try:
for sender in senders:
_plano.wait_for_process(sender)
for receiver in receivers:
_plano.wait_for_process(receiver)
except:
for sender in senders:
_plano.stop_process(sender)
for receiver in receivers:
_plano.stop_process(receiver)
raise
for sender in senders:
if sender.returncode != 0:
exit_code = 1
break
for receiver in receivers:
if receiver.returncode != 0:
exit_code = 1
break
except KeyboardInterrupt:
pass
except:
_traceback.print_exc()
exit_code = 1
finally:
_plano.exit(exit_code)
def run(self):
exit_code = 0
sender_command = ["quiver-arrow", "send", self.url, "--impl", self.sender_impl, "--verbose"]
sender_command += self.sender_options
receiver_command = ["quiver-arrow", "receive", self.url, "--impl", self.receiver_impl, "--verbose"]
receiver_command += self.receiver_options
senders = list()
receivers = list()
for i in range(self.receiver_count):
receiver = _plano.start_process(receiver_command)
receivers.append(receiver)
_plano.wait_for_port(self.port)
for i in range(self.sender_count):
sender = _plano.start_process(sender_command)
senders.append(sender)
try:
try:
for sender in senders:
_plano.wait_for_process(sender)
for receiver in receivers:
_plano.wait_for_process(receiver)
except:
for sender in senders:
_plano.stop_process(sender)
for receiver in receivers:
_plano.stop_process(receiver)
raise
for sender in senders:
if sender.returncode != 0:
exit_code = 1
break
for receiver in receivers:
if receiver.returncode != 0:
exit_code = 1
break
except KeyboardInterrupt:
pass
except:
_traceback.print_exc()
exit_code = 1
finally:
_plano.exit(exit_code)
def run(self):
args = [
self.url,
"--messages", self.args.messages,
"--body-size", self.args.body_size,
"--credit", self.args.credit,
"--transaction-size", self.args.transaction_size,
"--timeout", self.args.timeout,
"--output", self.output_dir,
]
if self.durable:
args += ["--durable"]
if self.quiet:
args += ["--quiet"]
if self.verbose:
args += ["--verbose"]
sender_args = ["quiver-arrow", "send", "--impl", self.sender_impl.name] + args
receiver_args = ["quiver-arrow", "receive", "--impl", self.receiver_impl.name] + args
if self.peer_to_peer:
receiver_args += ["--server", "--passive"]
self.start_time = now()
receiver = _plano.start_process(receiver_args)
if self.peer_to_peer:
_plano.wait_for_port(self.port, host=self.host)
sender = _plano.start_process(sender_args)
try:
if not self.quiet:
self.print_status(sender, receiver)
_plano.wait_for_process(sender)
_plano.wait_for_process(receiver)
except:
_plano.stop_process(sender)
_plano.stop_process(receiver)
raise
if (sender.returncode, receiver.returncode) != (0, 0):
_plano.exit(1)
if not self.quiet:
self.print_summary()
def start(self, port):
assert self.proc is None
_plano.make_dir(self.output_dir)
self.output = open(self.output_file, "w")
command = [
"quiver-server",
"//localhost:{}/q0".format(port),
"--impl",
self.impl,
"--ready-file",
self.ready_file,
"--verbose",
]
_plano.write(self.command_file, "{}\n".format(" ".join(command)))
self.proc = _plano.start_process(command,
stdout=self.output,
stderr=self.output)
for i in range(30):
if _plano.read(self.ready_file) == "ready\n":
break
_plano.sleep(0.2)
else:
raise _Timeout("Timed out waiting for server to be ready")
def start(self, port):
assert self.proc is None
_plano.make_dir(self.output_dir)
self.output = open(self.output_file, "w")
command = [
"quiver-server", "//127.0.0.1:{}/q0".format(port),
"--impl", self.impl,
"--ready-file", self.ready_file,
"--verbose",
]
_plano.write(self.command_file, "{}\n".format(" ".join(command)))
self.proc = _plano.start_process(command, stdout=self.output, stderr=self.output)
for i in range(30):
if _plano.read(self.ready_file) == "ready\n":
break
_plano.sleep(0.2)
else:
raise _Timeout("Timed out waiting for server to be ready")
def run(self):
args = self.prelude + [
self.impl.file,
"connection-mode={}".format(self.connection_mode),
"channel-mode={}".format(self.channel_mode),
"operation={}".format(self.operation),
"id={}".format(self.id_),
"scheme={}".format(self.scheme),
"host={}".format(self.host),
"port={}".format(self.port),
"path={}".format(self.path),
"duration={}".format(self.duration),
"count={}".format(self.count),
"rate={}".format(self.rate),
"body-size={}".format(self.body_size),
"credit-window={}".format(self.credit_window),
"transaction-size={}".format(self.transaction_size),
"durable={}".format(1 if self.durable else 0),
]
if self.username:
args.append("username={}".format(self.username))
if self.password:
args.append("password={}".format(self.password))
if self.args.cert and self.args.key:
args.append("key={}".format(self.key))
args.append("cert={}".format(self.cert))
with open(self.transfers_file, "wb") as fout:
env = _plano.ENV
if self.verbose:
env["QUIVER_VERBOSE"] = "1"
proc = _plano.start_process(args, stdout=fout, env=env)
try:
self.monitor_subprocess(proc)
except:
_plano.stop_process(proc)
raise
if proc.returncode != 0:
raise CommandError("{} exited with code {}", self.role, proc.returncode)
if _plano.file_size(self.transfers_file) == 0:
raise CommandError("No transfers")
self.compute_results()
self.save_summary()
if _plano.exists("{}.xz".format(self.transfers_file)):
_plano.remove("{}.xz".format(self.transfers_file))
_plano.call("xz --compress -0 --threads 0 {}", self.transfers_file)
if (self.args.summary):
self.print_summary()
def run(self):
args = self.prelude + [
self.impl.file,
"connection-mode={}".format(self.connection_mode),
"channel-mode={}".format(self.channel_mode),
"operation={}".format(self.operation),
"id={}".format(self.id_),
"scheme={}".format(self.scheme),
"host={}".format(self.host),
"port={}".format(self.port),
"path={}".format(self.path),
"duration={}".format(self.duration),
"count={}".format(self.count),
"body-size={}".format(self.body_size),
"credit-window={}".format(self.credit_window),
"transaction-size={}".format(self.transaction_size),
"durable={}".format(1 if self.durable else 0),
]
if self.username:
args.append("username={}".format(self.username))
if self.password:
args.append("password={}".format(self.password))
if self.args.cert and self.args.key:
args.append("key={}".format(self.key))
args.append("cert={}".format(self.cert))
with open(self.transfers_file, "wb") as fout:
env = _plano.ENV
if self.verbose:
env["QUIVER_VERBOSE"] = "1"
proc = _plano.start_process(args, stdout=fout, env=env)
try:
self.monitor_subprocess(proc)
except:
_plano.stop_process(proc)
raise
if proc.returncode != 0:
raise CommandError("{} exited with code {}", self.role, proc.returncode)
if _plano.file_size(self.transfers_file) == 0:
raise CommandError("No transfers")
self.compute_results()
self.save_summary()
if _plano.exists("{}.xz".format(self.transfers_file)):
_plano.remove("{}.xz".format(self.transfers_file))
_plano.call("xz --compress -0 --threads 0 {}", self.transfers_file)
def run(self):
args = self.prelude + [
self.impl.file,
self.connection_mode,
self.channel_mode,
self.operation,
self.id_,
self.host,
self.port,
self.path,
str(self.duration),
str(self.count),
str(self.body_size),
str(self.credit_window),
str(self.transaction_size),
self.flags,
]
assert None not in args, args
with open(self.transfers_file, "wb") as fout:
env = _plano.ENV
if self.verbose:
env["QUIVER_VERBOSE"] = "1"
proc = _plano.start_process(args, stdout=fout, env=env)
try:
self.monitor_subprocess(proc)
except:
_plano.stop_process(proc)
raise
if proc.returncode != 0:
raise CommandError("{} exited with code {}", self.role,
proc.returncode)
if _plano.file_size(self.transfers_file) == 0:
raise CommandError("No transfers")
self.compute_results()
self.save_summary()
if _plano.exists("{}.xz".format(self.transfers_file)):
_plano.remove("{}.xz".format(self.transfers_file))
_plano.call("xz --compress -0 --threads 0 {}", self.transfers_file)
def run(self):
args = self.prelude + [
self.impl_file,
self.connection_mode,
self.channel_mode,
self.operation,
self.id_,
self.host,
self.port,
self.path,
str(self.messages),
str(self.body_size),
str(self.credit_window),
]
assert None not in args, args
with open(self.transfers_file, "wb") as fout:
_plano.notice("Calling '{}'", " ".join(args))
proc = _plano.start_process(args, stdout=fout)
try:
self.monitor_subprocess(proc)
except:
_plano.stop_process(proc)
raise
if proc.returncode != 0:
raise CommandError("{} exited with code {}", self.role,
proc.returncode)
if _os.path.getsize(self.transfers_file) == 0:
raise CommandError("No transfers")
self.compute_results()
self.save_summary()
_plano.call("xz --compress -0 --threads 0 {}", self.transfers_file)
def run(self):
args = list()
if self.duration == 0:
args += ["--count", self.args.count]
else:
args += ["--duration", self.args.duration]
args += [
"--body-size",
self.args.body_size,
"--credit",
self.args.credit,
"--transaction-size",
self.args.transaction_size,
"--timeout",
self.args.timeout,
]
if self.durable:
args += ["--durable"]
if self.quiet:
args += ["--quiet"]
if self.verbose:
args += ["--verbose"]
if self.username:
args.append("username={}".format(self.username))
if self.password:
args.append("password={}".format(self.password))
if self.args.cert and self.args.key:
args += ["--key", self.args.key]
args += ["--cert", self.args.cert]
args += ["--output", self.output_dir]
sender_args = [
"quiver-arrow", "send", self.url, "--impl", self.sender_impl.name
] + args
receiver_args = [
"quiver-arrow", "receive", self.url, "--impl",
self.receiver_impl.name
] + args
if self.peer_to_peer:
receiver_args += ["--server", "--passive"]
self.start_time = now()
#_os.environ["DEBUG"] = "*"
receiver = _plano.start_process(receiver_args)
#del _os.environ["DEBUG"]
if self.peer_to_peer:
_plano.wait_for_port(self.port, host=self.host)
#_os.environ["PN_TRACE_FRM"] = "1"
sender = _plano.start_process(sender_args)
#del _os.environ["PN_TRACE_FRM"]
try:
if not self.quiet:
self.print_status(sender, receiver)
_plano.check_process(receiver)
_plano.check_process(sender)
except _plano.CalledProcessError as e:
_plano.error(e)
finally:
_plano.stop_process(sender)
_plano.stop_process(receiver)
if (sender.returncode, receiver.returncode) != (0, 0):
_plano.exit(1)
if not self.quiet:
self.print_summary()
def run(self):
args = list()
if self.duration == 0:
args += ["--count", self.args.count]
else:
args += ["--duration", self.args.duration]
args += [
"--body-size", self.args.body_size,
"--credit", self.args.credit,
"--transaction-size", self.args.transaction_size,
"--timeout", self.args.timeout,
]
if self.durable:
args += ["--durable"]
if self.quiet:
args += ["--quiet"]
if self.verbose:
args += ["--verbose"]
if self.args.cert and self.args.key:
args += ["--key", self.args.key]
args += ["--cert", self.args.cert]
args += ["--output", self.output_dir]
sender_args = ["quiver-arrow", "send", self.url, "--impl", self.sender_impl.name] + args
receiver_args = ["quiver-arrow", "receive", self.url, "--impl", self.receiver_impl.name] + args
if self.peer_to_peer:
receiver_args += ["--server", "--passive"]
self.start_time = now()
#_os.environ["DEBUG"] = "*"
receiver = _plano.start_process(receiver_args)
#del _os.environ["DEBUG"]
if self.peer_to_peer:
_plano.wait_for_port(self.port, host=self.host)
#_os.environ["PN_TRACE_FRM"] = "1"
sender = _plano.start_process(sender_args)
#del _os.environ["PN_TRACE_FRM"]
try:
if not self.quiet:
self.print_status(sender, receiver)
_plano.check_process(receiver)
_plano.check_process(sender)
except _plano.CalledProcessError as e:
_plano.error(e)
finally:
_plano.stop_process(sender)
_plano.stop_process(receiver)
if (sender.returncode, receiver.returncode) != (0, 0):
_plano.exit(1)
if not self.quiet:
self.print_summary()
