def capture_journal(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
"""
formatter = journald_json_formatter(output_file)
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'journalctl',
b'--lines', b'0',
b'--output', b'export',
b'--follow',
# Only bother with units we care about:
b'-u', b'docker',
b'-u', b'flocker-control',
b'-u', b'flocker-dataset-agent',
b'-u', b'flocker-container-agent',
b'-u', b'flocker-docker-plugin',
],
handle_stdout=formatter,
)
ran.addErrback(write_failure, logger=None)
# Deliver a final empty line to process the last message
ran.addCallback(lambda ignored: formatter(b""))
def capture_journal(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
:return deferred: that will run the journalctl command
"""
formatter = journald_json_formatter(output_file)
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'journalctl',
b'--lines', b'0',
b'--output', b'export',
b'--follow',
# Only bother with units we care about:
b'-u', b'docker',
b'-u', b'flocker-control',
b'-u', b'flocker-dataset-agent',
b'-u', b'flocker-container-agent',
b'-u', b'flocker-docker-plugin',
],
handle_stdout=formatter,
)
ran.addErrback(write_failure, logger=None)
# Deliver a final empty line to process the last message
ran.addCallback(lambda ignored: formatter(b""))
return ran
def capture_journal(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
"""
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'journalctl',
b'--lines', b'0',
b'--follow',
# Only bother with units we care about:
b'-u', b'docker',
b'-u', b'flocker-control',
b'-u', b'flocker-dataset-agent',
b'-u', b'flocker-container-agent',
b'-u', b'flocker-docker-plugin',
],
handle_stdout=lambda line: output_file.write(line + b'\n')
)
ran.addErrback(write_failure, logger=None)
def capture_upstart(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
:return deferred: that will run the tail command
"""
# note that we are using tail -F to keep retrying and not to exit when we
# reach the end of the file, as we expect the logs to keep being generated
formatter = TailFormatter(output_file, host)
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'tail',
b'-F',
b'/var/log/flocker/flocker-control.log',
b'/var/log/flocker/flocker-dataset-agent.log',
b'/var/log/flocker/flocker-container-agent.log',
b'/var/log/flocker/flocker-docker-plugin.log',
b'/var/log/upstart/docker.log',
],
handle_stdout=formatter.handle_output_line,
)
ran.addErrback(write_failure, logger=None)
# Deliver a final empty line to process the last message
ran.addCallback(lambda ignored: formatter.handle_output_line(b""))
return ran
def capture_upstart(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
:return deferred: that will run the tail command
"""
# note that we are using tail -F to keep retrying and not to exit when we
# reach the end of the file, as we expect the logs to keep being generated
formatter = TailFormatter(output_file, host)
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'tail',
b'-F',
b'/var/log/flocker/flocker-control.log',
b'/var/log/flocker/flocker-dataset-agent.log',
b'/var/log/flocker/flocker-container-agent.log',
b'/var/log/flocker/flocker-docker-plugin.log',
b'/var/log/upstart/docker.log',
],
handle_stdout=formatter.handle_output_line,
)
ran.addErrback(write_failure, logger=None)
# Deliver a final empty line to process the last message
ran.addCallback(lambda ignored: formatter.handle_output_line(b""))
return ran
def capture_journal(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
"""
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'journalctl',
b'--lines',
b'0',
b'--follow',
# Only bother with units we care about:
b'-u',
b'docker',
b'-u',
b'flocker-control',
b'-u',
b'flocker-dataset-agent',
b'-u',
b'flocker-container-agent',
],
handle_stdout=lambda line: output_file.write(line + b'\n'))
ran.addErrback(write_failure, logger=None)
def remote_command(client_ip, command):
"""
Run ``command`` on ``client_ip``.
:returns: A ``Deferred`` when the command has completed or failed.
"""
process_output = []
d = run_ssh(reactor,
'ubuntu',
client_ip,
command,
handle_stdout=process_output.append)
d.addCallback(lambda process_result: (process_result, process_output))
return d
def run(self, node, command_args, handle_stdout):
"""
Run a command using SSH.
:param Node node: Node to run command on.
:param [str] command_args: List of command line arguments.
:param callable handle_stdout: Function to handle each line of output.
:return: Deferred, firing when complete.
"""
d = run_ssh(
self.reactor,
self.user,
self.cluster.public_address(node.public_address).exploded,
command_args,
handle_stdout=handle_stdout,
)
return d
def run(self, node, command_args, handle_stdout):
"""
Run a command using SSH.
:param Node node: Node to run command on.
:param [str] command_args: List of command line arguments.
:param callable handle_stdout: Function to handle each line of output.
:return: Deferred, firing when complete.
"""
d = run_ssh(
self.reactor,
self.user,
self.cluster.public_address(node.public_address).exploded,
command_args,
handle_stdout=handle_stdout,
)
return d
def remote_command(client_ip, command):
"""
Run ``command`` on ``client_ip``.
:returns: A ``Deferred`` when the command has completed or failed.
"""
process_output = []
d = run_ssh(
reactor,
'ubuntu',
client_ip,
command,
handle_stdout=process_output.append
)
d.addCallback(
lambda process_result: (process_result, process_output)
)
return d
def run(self, node, command_args, handle_stdout):
"""
Run a command using SSH.
:param Node node: Node to run command on.
:param [str] command_args: List of command line arguments.
:param callable handle_stdout: Function to handle each line of output.
:return: Deferred, firing when complete.
"""
hostname = node.public_address.exploded
# Map hostname to public IP address. If not in mapping, use hostname.
public_ip = self.node_mapping.get(hostname, hostname)
d = run_ssh(
self.reactor,
self.user,
public_ip,
command_args,
handle_stdout=handle_stdout,
)
return d
def capture_upstart(reactor, host, output_file):
"""
SSH into given machine and capture relevant logs, writing them to
output file.
:param reactor: The reactor.
:param bytes host: Machine to SSH into.
:param file output_file: File to write to.
:return deferred: that will run the tail command
"""
# note that we are using tail -F to keep retrying and not to exit when we
# reach the end of the file, as we expect the logs to keep being generated
results = []
for (directory, service) in [
(b"flocker", b"flocker-control"),
(b"flocker", b"flocker-dataset-agent"),
(b"flocker", b"flocker-container-agent"),
(b"flocker", b"flocker-docker-plugin"),
(b"upstart", b"docker")]:
path = FilePath(b'/var/log/').child(directory).child(service + b'.log')
formatter = TailFormatter(output_file, host, service)
ran = run_ssh(
reactor=reactor,
host=host,
username='******',
command=[
b'tail',
b'-F',
path.path
],
handle_stdout=formatter.handle_output_line,
)
ran.addErrback(write_failure, logger=None)
# Deliver a final empty line to process the last message
ran.addCallback(lambda ignored, formatter=formatter:
formatter.handle_output_line(b""))
results.append(ran)
return gather_deferreds(results)
