1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
# Copyright 2019 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Implements commands for running/interacting with Fuchsia on an emulator."""
import pkg_repo
import boot_data
import logging
import os
import runner_logs
import subprocess
import sys
import target
import tempfile
class EmuTarget(target.Target):
def __init__(self, out_dir, target_cpu, system_log_file):
"""out_dir: The directory which will contain the files that are
generated to support the emulator deployment.
target_cpu: The emulated target CPU architecture.
Can be 'x64' or 'arm64'."""
super(EmuTarget, self).__init__(out_dir, target_cpu)
self._emu_process = None
self._system_log_file = system_log_file
self._pkg_repo = None
def __enter__(self):
return self
def _BuildCommand(self):
"""Build the command that will be run to start Fuchsia in the emulator."""
pass
def _SetEnv(self):
return os.environ.copy()
# Used by the context manager to ensure that the emulator is killed when
# the Python process exits.
def __exit__(self, exc_type, exc_val, exc_tb):
self.Shutdown();
def Start(self):
emu_command = self._BuildCommand()
# We pass a separate stdin stream. Sharing stdin across processes
# leads to flakiness due to the OS prematurely killing the stream and the
# Python script panicking and aborting.
# The precise root cause is still nebulous, but this fix works.
# See crbug.com/741194.
logging.debug('Launching %s.' % (self.EMULATOR_NAME))
logging.debug(' '.join(emu_command))
# Zircon sends debug logs to serial port (see kernel.serial=legacy flag
# above). Serial port is redirected to a file through emulator stdout.
# If runner_logs are not enabled, we output the kernel serial log
# to a temporary file, and print that out if we are unable to connect to
# the emulator guest, to make it easier to diagnose connectivity issues.
temporary_log_file = None
if runner_logs.IsEnabled():
stdout = runner_logs.FileStreamFor('serial_log')
else:
temporary_log_file = tempfile.NamedTemporaryFile('w')
stdout = temporary_log_file
LogProcessStatistics('proc_stat_start_log')
LogSystemStatistics('system_statistics_start_log')
self._emu_process = subprocess.Popen(emu_command,
stdin=open(os.devnull),
stdout=stdout,
stderr=subprocess.STDOUT,
env=self._SetEnv())
try:
self._WaitUntilReady()
LogProcessStatistics('proc_stat_ready_log')
except target.FuchsiaTargetException:
if temporary_log_file:
logging.info('Kernel logs:\n' +
open(temporary_log_file.name, 'r').read())
raise
def GetPkgRepo(self):
if not self._pkg_repo:
self._pkg_repo = pkg_repo.ManagedPkgRepo(self)
return self._pkg_repo
def Shutdown(self):
if not self._emu_process:
logging.error('%s did not start' % (self.EMULATOR_NAME))
return
returncode = self._emu_process.poll()
if returncode == None:
logging.info('Shutting down %s' % (self.EMULATOR_NAME))
self._emu_process.kill()
elif returncode == 0:
logging.info('%s quit unexpectedly without errors' % self.EMULATOR_NAME)
elif returncode < 0:
logging.error('%s was terminated by signal %d' %
(self.EMULATOR_NAME, -returncode))
else:
logging.error('%s quit unexpectedly with exit code %d' %
(self.EMULATOR_NAME, returncode))
LogProcessStatistics('proc_stat_end_log')
LogSystemStatistics('system_statistics_end_log')
def _IsEmuStillRunning(self):
if not self._emu_process:
return False
return os.waitpid(self._emu_process.pid, os.WNOHANG)[0] == 0
def _GetEndpoint(self):
if not self._IsEmuStillRunning():
raise Exception('%s quit unexpectedly.' % (self.EMULATOR_NAME))
return ('localhost', self._host_ssh_port)
def _GetSshConfigPath(self):
return boot_data.GetSSHConfigPath()
def LogSystemStatistics(log_file_name):
statistics_log = runner_logs.FileStreamFor(log_file_name)
# Log the cpu load and process information.
subprocess.call(['top', '-b', '-n', '1'],
stdin=open(os.devnull),
stdout=statistics_log,
stderr=subprocess.STDOUT)
subprocess.call(['ps', '-ax'],
stdin=open(os.devnull),
stdout=statistics_log,
stderr=subprocess.STDOUT)
def LogProcessStatistics(log_file_name):
statistics_log = runner_logs.FileStreamFor(log_file_name)
subprocess.call(['cat', '/proc/stat'],
stdin=open(os.devnull),
stdout=statistics_log,
stderr=subprocess.STDOUT)
|
