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
146
147
148
149
150
151
152
153
154
155
156
157
158
|
# Copyright 2018 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.
import argparse
import importlib
import logging
import os
import sys
from common import GetHostArchFromPlatform
def _AddTargetSpecificationArgs(arg_parser):
"""Returns a parser that handles the target type used for the test run."""
device_args = arg_parser.add_argument_group(
'target',
'Arguments specifying the Fuchsia target type. To see a list of '
'arguments available for a specific target type, specify the desired '
'target to use and add the --help flag.')
device_args.add_argument('--target-cpu',
default=GetHostArchFromPlatform(),
help='GN target_cpu setting for the build. Defaults '
'to the same architecture as host cpu.')
device_args.add_argument('--device',
default=None,
choices=['aemu', 'qemu', 'device', 'custom'],
help='Choose to run on aemu|qemu|device. '
'By default, Fuchsia will run on AEMU on x64 '
'hosts and QEMU on arm64 hosts. Alternatively, '
'setting to custom will require specifying the '
'subclass of Target class used via the '
'--custom-device-target flag.')
device_args.add_argument('-d',
action='store_const',
dest='device',
const='device',
help='Run on device instead of emulator.')
device_args.add_argument('--custom-device-target',
default=None,
help='Specify path to file that contains the '
'subclass of Target that will be used. Only '
'needed if device specific operations such as '
'paving is required.')
device_args.add_argument('--fuchsia-out-dir',
help='Path to a Fuchsia build output directory. '
'Setting the GN arg '
'"default_fuchsia_build_dir_for_installation" '
'will cause it to be passed here.')
def _GetTargetClass(args):
"""Gets the target class to be used for the test run."""
if args.device == 'custom':
if not args.custom_device_target:
raise Exception('--custom-device-target flag must be set when device '
'flag set to custom.')
target_path = args.custom_device_target
else:
if not args.device:
args.device = 'aemu' if args.target_cpu == 'x64' else 'qemu'
target_path = '%s_target' % args.device
try:
loaded_target = importlib.import_module(target_path)
except ImportError:
logging.error('Cannot import from %s. Make sure that --ext-device-path '
'is pointing to a file containing a target '
'module.' % target_path)
raise
return loaded_target.GetTargetType()
def AddCommonArgs(arg_parser):
"""Adds command line arguments to |arg_parser| for options which are shared
across test and executable target types.
Args:
arg_parser: an ArgumentParser object."""
_AddTargetSpecificationArgs(arg_parser)
# Parse the args used to specify target
module_args, _ = arg_parser.parse_known_args()
# Determine the target class and register target specific args.
target_class = _GetTargetClass(module_args)
target_class.RegisterArgs(arg_parser)
package_args = arg_parser.add_argument_group('package', 'Fuchsia Packages')
package_args.add_argument(
'--package',
action='append',
help='Paths of the packages to install, including '
'all dependencies.')
package_args.add_argument(
'--package-name',
help='Name of the package to execute, defined in ' + 'package metadata.')
common_args = arg_parser.add_argument_group('common', 'Common arguments')
common_args.add_argument('--runner-logs-dir',
help='Directory to write test runner logs to.')
common_args.add_argument('--exclude-system-logs',
action='store_false',
dest='include_system_logs',
help='Do not show system log data.')
common_args.add_argument('--verbose', '-v', default=False,
action='store_true',
help='Enable debug-level logging.')
def ConfigureLogging(args):
"""Configures the logging level based on command line |args|."""
logging.basicConfig(level=(logging.DEBUG if args.verbose else logging.INFO),
format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
# The test server spawner is too noisy with INFO level logging, so tweak
# its verbosity a bit by adjusting its logging level.
logging.getLogger('chrome_test_server_spawner').setLevel(
logging.DEBUG if args.verbose else logging.WARN)
# Verbose SCP output can be useful at times but oftentimes is just too noisy.
# Only enable it if -vv is passed.
logging.getLogger('ssh').setLevel(
logging.DEBUG if args.verbose else logging.WARN)
# TODO(crbug.com/1121763): remove the need for additional_args
def GetDeploymentTargetForArgs(additional_args=None):
"""Constructs a deployment target object using command line arguments.
If needed, an additional_args dict can be used to supplement the
command line arguments."""
# Determine target type from command line arguments.
device_type_parser = argparse.ArgumentParser()
_AddTargetSpecificationArgs(device_type_parser)
module_args, _ = device_type_parser.parse_known_args()
target_class = _GetTargetClass(module_args)
# Process command line args needed to initialize target in separate arg
# parser.
target_arg_parser = argparse.ArgumentParser()
target_class.RegisterArgs(target_arg_parser)
known_args, _ = target_arg_parser.parse_known_args()
target_args = vars(known_args)
# target_cpu is needed to determine target type, and fuchsia_out_dir
# is needed for devices with Fuchsia built from source code.
target_args.update({'target_cpu': module_args.target_cpu})
target_args.update({'fuchsia_out_dir': module_args.fuchsia_out_dir})
if additional_args:
target_args.update(additional_args)
return target_class(**target_args)
|
