def __init__(self, platform_backend, supports_tab_control,
supports_extensions, browser_options, output_profile_path,
extensions_to_load):
super(ChromeBrowserBackend,
self).__init__(platform_backend=platform_backend,
supports_extensions=supports_extensions,
browser_options=browser_options,
tab_list_backend=tab_list_backend.TabListBackend)
self._port = None
self._supports_tab_control = supports_tab_control
self._devtools_client = None
self._system_info_backend = None
self._output_profile_path = output_profile_path
self._extensions_to_load = extensions_to_load
if browser_options.netsim:
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(443, 443),
dns=forwarders.PortPair(53, 53))
else:
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(0, 0),
https=forwarders.PortPair(0, 0),
dns=None)
if (self.browser_options.dont_override_profile
and not options_for_unittests.AreSet()):
sys.stderr.write(
'Warning: Not overriding profile. This can cause '
'unexpected effects due to profile-specific settings, '
'such as about:flags settings, cookies, and '
'extensions.\n')
def GetWprPortPairs(self, has_netsim):
"""Return suitable port pairs to be used for web page replay."""
if has_netsim:
return forwarders.PortPairs(http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(443, 443),
dns=forwarders.PortPair(53, 53))
else:
return forwarders.PortPairs(http=forwarders.PortPair(0, 0),
https=forwarders.PortPair(0, 0),
dns=None)
def testZeroIsOkayForRemotePorts(self):
started_ports = (8080, 8443, None)
wpr_port_pairs = forwarders.PortPairs(http=forwarders.PortPair(0, 0),
https=forwarders.PortPair(0, 0),
dns=None)
expected_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(8080, 0),
https=forwarders.PortPair(8443, 0),
dns=None)
self.assertEqual(
expected_port_pairs,
network_controller_backend._ForwarderPortPairs(
started_ports, wpr_port_pairs))
def testCombineStartedAndRemotePorts(self):
started_ports = (8888, 4343, 5353)
wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(0, 80),
https=forwarders.PortPair(0, 443),
dns=forwarders.PortPair(0, 53))
expected_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(8888, 80),
https=forwarders.PortPair(4343, 443),
dns=forwarders.PortPair(5353, 53))
self.assertEqual(
expected_port_pairs,
network_controller_backend._ForwarderPortPairs(started_ports,
wpr_port_pairs))
def Start(self, local_server_controller):
assert self._subprocess == None
self._local_server_controller = local_server_controller
self.host_ip = local_server_controller.host_ip
server_args = self.GetBackendStartupArgs()
server_args_as_json = json.dumps(server_args)
server_module_name = self._server_backend_class.__module__
self._devnull = open(os.devnull, 'w')
cmd = [
sys.executable, '-m', __name__,
'run_backend',
server_module_name,
self._server_backend_class.__name__,
server_args_as_json,
]
env = os.environ.copy()
env['PYTHONPATH'] = os.pathsep.join(sys.path)
self._subprocess = subprocess.Popen(
cmd, cwd=util.GetTelemetryDir(), env=env, stdout=subprocess.PIPE)
named_ports = self._GetNamedPortsFromBackend()
named_port_pair_map = {'http': None, 'https': None, 'dns': None}
for name, port in named_ports:
assert name in named_port_pair_map, '%s forwarding is unsupported' % name
named_port_pair_map[name] = (
forwarders.PortPair(port,
local_server_controller.GetRemotePort(port)))
self.forwarder = local_server_controller.CreateForwarder(
forwarders.PortPairs(**named_port_pair_map))
def __init__(self, port_pairs):
super(DoNothingForwarder, self).__init__(
forwarders.PortPairs(*[
forwarders.PortPair(p.local_port, p.remote_port or p.local_port
) if p else None for p in port_pairs
]))
self._CheckPortPairs()
def testGetRemotePortAndIsHTTPServerRunningOnPort(self):
with self._GetCRI() as cri:
# Create local server.
sock = socket.socket()
sock.bind(('', 0))
port = sock.getsockname()[1]
sock.listen(0)
# Get remote port and ensure that it was unused.
remote_port = cri.GetRemotePort()
self.assertFalse(cri.IsHTTPServerRunningOnPort(remote_port))
# Forward local server's port to remote device's remote_port.
forwarder = cros_forwarder.CrOsForwarderFactory(cri).Create(
forwarders.PortPairs(http=forwarders.PortPair(
port, remote_port),
https=None,
dns=None))
# At this point, remote device should be able to connect to local server.
self.assertTrue(cri.IsHTTPServerRunningOnPort(remote_port))
# Next remote port shouldn't be the same as remote_port, since remote_port
# is now in use.
self.assertTrue(cri.GetRemotePort() != remote_port)
# Close forwarder and local server ports.
forwarder.Close()
sock.close()
# Device should no longer be able to connect to remote_port since it is no
# longer in use.
self.assertFalse(cri.IsHTTPServerRunningOnPort(remote_port))
def _ForwarderPortPairs(started_ports, wpr_port_pairs):
"""Return PortPairs with started local ports and requested remote ports.
The local host is where Telemetry is run. The remote is host where
the target application is run. The local and remote hosts may be
the same (e.g., testing a desktop browser) or different (e.g., testing
an android browser).
The remote ports may be zero. In that case, the forwarder determines
the remote ports.
Args:
started_ports: a tuple of of integer ports from which to forward:
(HTTP_PORT, HTTPS_PORT, DNS_PORT) # DNS_PORT may be None
wpr_port_pairs: a forwarders.PortPairs instance where the remote ports,
if set, are used.
Returns:
a forwarders.PortPairs instance used to create the forwarder.
"""
local_http_port, local_https_port, local_dns_port = started_ports
return forwarders.PortPairs(
forwarders.PortPair(local_http_port, wpr_port_pairs.http.remote_port),
forwarders.PortPair(local_https_port,
wpr_port_pairs.https.remote_port),
(forwarders.PortPair(local_dns_port, wpr_port_pairs.dns.remote_port)
if wpr_port_pairs.dns is not None else None))
def testPortMismatchRaisesPortsMismatchError(self):
# The do_nothing_forward cannot forward from one port to another.
port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(8443, 443),
dns=None)
with self.assertRaises(do_nothing_forwarder.PortsMismatchError):
TestDoNothingForwarder(port_pairs)
def Start(self):
# Escape all commas in the startup arguments we pass to Chrome
# because dbus-send delimits array elements by commas
startup_args = [
a.replace(',', '\\,') for a in self.GetBrowserStartupArgs()
]
# Restart Chrome with the login extension and remote debugging.
logging.info('Restarting Chrome with flags and login')
args = [
'dbus-send', '--system', '--type=method_call',
'--dest=org.chromium.SessionManager',
'/org/chromium/SessionManager',
'org.chromium.SessionManagerInterface.EnableChromeTesting',
'boolean:true',
'array:string:"%s"' % ','.join(startup_args)
]
self._cri.RunCmdOnDevice(args)
if not self._cri.local:
# TODO(crbug.com/404771): Move port forwarding to network_controller.
self._port = util.GetUnreservedAvailableLocalPort()
self._forwarder = self._platform_backend.forwarder_factory.Create(
forwarders.PortPairs(http=forwarders.PortPair(
self._port, self._remote_debugging_port),
https=None,
dns=None),
use_remote_port_forwarding=False)
# Wait for oobe.
self._WaitForBrowserToComeUp()
self._InitDevtoolsClientBackend(
remote_devtools_port=self._remote_debugging_port)
util.WaitFor(lambda: self.oobe_exists, 30)
if self.browser_options.auto_login:
try:
if self._is_guest:
pid = self.pid
self.oobe.NavigateGuestLogin()
# Guest browsing shuts down the current browser and launches an
# incognito browser in a separate process, which we need to wait for.
util.WaitFor(lambda: pid != self.pid, 10)
elif self.browser_options.gaia_login:
self.oobe.NavigateGaiaLogin(self._username, self._password)
else:
self.oobe.NavigateFakeLogin(
self._username, self._password, self._gaia_id,
not self.browser_options.disable_gaia_services)
self._WaitForLogin()
except exceptions.TimeoutException:
self._cri.TakeScreenshotWithPrefix('login-screen')
raise exceptions.LoginException(
'Timed out going through login screen. ' +
self._GetLoginStatus())
logging.info('Browser is up!')
def __init__(self, device, port_pairs):
super(AndroidForwarder, self).__init__(port_pairs)
self._device = device
forwarder.Forwarder.Map([(p.remote_port, p.local_port)
for p in port_pairs if p], self._device)
self._port_pairs = forwarders.PortPairs(*[
forwarders.PortPair(
p.local_port,
forwarder.Forwarder.DevicePortForHostPort(p.local_port))
if p else None for p in port_pairs])
def main():
constants.SetBuildType(BUILD_TYPE)
# Install APK
device = GetDevice()
device.EnableRoot()
device.Install(APP_APK)
# Start USB reverse tethering.
# Port map is ignored for tethering; must create one to placate assertions.
named_port_pair_map = {
'http': (forwarders.PortPair(0, 0)),
'https': None,
'dns': None
}
port_pairs = forwarders.PortPairs(**named_port_pair_map)
forwarder = GetForwarderFactory(device).Create(port_pairs)
# Start HTTP server.
http_server_doc_root = GenerateHttpTestResources()
config_file = tempfile.NamedTemporaryFile()
http_server = lighttpd_server.LighttpdServer(
http_server_doc_root,
port=HTTP_PORT,
base_config_path=config_file.name)
GenerateLighttpdConfig(config_file, http_server_doc_root, http_server)
assert http_server.StartupHttpServer()
config_file.close()
# Start QUIC server.
quic_server_doc_root = GenerateQuicTestResources(device)
quic_server = QuicServer(quic_server_doc_root)
quic_server.StartupQuicServer(device)
# Launch Telemetry's benchmark_runner on CronetPerfTestBenchmark.
# By specifying this file's directory as the benchmark directory, it will
# allow benchmark_runner to in turn open this file up and find the
# CronetPerfTestBenchmark class to run the benchmark.
top_level_dir = os.path.dirname(os.path.realpath(__file__))
# The perf config file is required to continue using dependencies on the
# Chromium checkout in Telemetry.
perf_config_file = os.path.join(REPOSITORY_ROOT, 'tools', 'perf', 'core',
'binary_dependencies.json')
with open(perf_config_file, "w") as config_file:
config_file.write('{"config_type": "BaseConfig"}')
runner_config = benchmark_runner.ProjectConfig(
top_level_dir=top_level_dir,
benchmark_dirs=[top_level_dir],
client_config=perf_config_file,
default_chrome_root=REPOSITORY_ROOT)
sys.argv.insert(1, 'run')
sys.argv.insert(2, 'run.CronetPerfTestBenchmark')
sys.argv.insert(3, '--android-rndis')
benchmark_runner.main(runner_config)
# Shutdown.
quic_server.ShutdownQuicServer()
shutil.rmtree(quic_server_doc_root)
http_server.ShutdownHttpServer()
shutil.rmtree(http_server_doc_root)
def testNoDnsStillChecksHttpHttps(self):
port_pairs = forwarders.PortPairs(http=forwarders.PortPair(5566, 5566),
https=forwarders.PortPair(
7788, 7788),
dns=None)
f = TestDoNothingForwarder(port_pairs)
expected_connected_addresses = [
('127.0.0.1', 5566),
('127.0.0.1', 7788),
]
self.assertEqual(expected_connected_addresses, f.connected_addresses)
def testChecksOnlyHttpHttps(self):
port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(443, 443),
dns=forwarders.PortPair(53, 53))
f = TestDoNothingForwarder(port_pairs)
expected_connected_addresses = [
('127.0.0.1', 80),
('127.0.0.1', 443),
# Port 53 is skipped because it is UDP and does not support connections.
]
self.assertEqual(expected_connected_addresses, f.connected_addresses)
def GetWprPortPairs(self, has_netsim):
"""Return suitable port pairs to be used for web page replay."""
if has_netsim:
assert self.use_rndis_forwarder, 'Netsim requires RNDIS forwarding.'
return forwarders.PortPairs(http=forwarders.PortPair(0, 80),
https=forwarders.PortPair(0, 443),
dns=forwarders.PortPair(0, 53))
else:
# Fall back to default port pairs.
return super(AndroidPlatformBackend,
self).GetWprPortPairs(has_netsim)
def __init__(self, android_platform_backend, browser_options,
backend_settings, output_profile_path, extensions_to_load,
target_arch):
assert isinstance(
android_platform_backend,
android_platform_backend_module.AndroidPlatformBackend)
super(AndroidBrowserBackend, self).__init__(
android_platform_backend,
supports_tab_control=backend_settings.supports_tab_control,
supports_extensions=False,
browser_options=browser_options,
output_profile_path=output_profile_path,
extensions_to_load=extensions_to_load)
if len(extensions_to_load) > 0:
raise browser_backend.ExtensionsNotSupportedException(
'Android browser does not support extensions.')
# Initialize fields so that an explosion during init doesn't break in Close.
self._backend_settings = backend_settings
self._target_arch = target_arch
self._saved_sslflag = ''
# TODO(tonyg): This is flaky because it doesn't reserve the port that it
# allocates. Need to fix this.
self._port = util.GetUnreservedAvailableLocalPort()
# TODO(wuhu): Move to network controller backend.
self.platform_backend.InstallTestCa()
# Kill old browser.
self._KillBrowser()
if self.device.HasRoot() or self.device.NeedsSU():
if self.browser_options.profile_dir:
self.platform_backend.PushProfile(
self._backend_settings.package,
self.browser_options.profile_dir)
elif not self.browser_options.dont_override_profile:
self.platform_backend.RemoveProfile(
self._backend_settings.package,
self._backend_settings.profile_ignore_list)
if self.browser_options.netsim:
assert self.platform_backend.use_rndis_forwarder, (
'Netsim requires RNDIS forwarding.')
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(0, 80),
https=forwarders.PortPair(0, 443),
dns=forwarders.PortPair(0, 53))
# Set the debug app if needed.
self.platform_backend.SetDebugApp(self._backend_settings.package)
def __init__(self, platform_backend, browser_options):
super(MandolineBrowserBackend,
self).__init__(platform_backend=platform_backend,
supports_extensions=False,
browser_options=browser_options,
tab_list_backend=tab_list_backend.TabListBackend)
self._port = None
self._devtools_client = None
if browser_options.netsim:
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(443, 443),
dns=forwarders.PortPair(53, 53))
else:
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(0, 0),
https=forwarders.PortPair(0, 0),
dns=None)
# Some of the browser options are not supported by mandoline yet.
self._CheckUnsupportedBrowserOptions(browser_options)
def __init__(self, cros_platform_backend, browser_options, cri, is_guest,
extensions_to_load):
super(CrOSBrowserBackend,
self).__init__(cros_platform_backend,
supports_tab_control=True,
supports_extensions=not is_guest,
browser_options=browser_options,
output_profile_path=None,
extensions_to_load=extensions_to_load)
assert browser_options.IsCrosBrowserOptions()
# Initialize fields so that an explosion during init doesn't break in Close.
self._cri = cri
self._is_guest = is_guest
self._forwarder = None
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(
self.wpr_port_pairs.http.local_port,
self._platform_backend.GetRemotePort(
self.wpr_port_pairs.http.local_port)),
https=forwarders.PortPair(
self.wpr_port_pairs.https.local_port,
self._platform_backend.GetRemotePort(
self.wpr_port_pairs.http.local_port)),
dns=None)
self._remote_debugging_port = self._cri.GetRemotePort()
self._port = self._remote_debugging_port
# Copy extensions to temp directories on the device.
# Note that we also perform this copy locally to ensure that
# the owner of the extensions is set to chronos.
for e in extensions_to_load:
extension_dir = cri.RunCmdOnDevice(
['mktemp', '-d', '/tmp/extension_XXXXX'])[0].rstrip()
e.local_path = os.path.join(extension_dir,
os.path.basename(e.path))
cri.PushFile(e.path, extension_dir)
cri.Chown(extension_dir)
self._cri.RestartUI(self.browser_options.clear_enterprise_policy)
util.WaitFor(self.IsBrowserRunning, 20)
# Delete test user's cryptohome vault (user data directory).
if not self.browser_options.dont_override_profile:
self._cri.RunCmdOnDevice([
'cryptohome', '--action=remove', '--force',
'--user=%s' % self._username
])
def main():
constants.SetBuildType(BUILD_TYPE)
# Install APK
device = GetDevice()
device.EnableRoot()
device.Install(APP_APK)
# Start USB reverse tethering.
# Port map is ignored for tethering; must create one to placate assertions.
named_port_pair_map = {
'http': (forwarders.PortPair(0, 0)),
'https': None,
'dns': None
}
port_pairs = forwarders.PortPairs(**named_port_pair_map)
forwarder = GetForwarderFactory(device).Create(port_pairs)
# Start HTTP server.
http_server_doc_root = GenerateHttpTestResources()
config_file = tempfile.NamedTemporaryFile()
http_server = lighttpd_server.LighttpdServer(
http_server_doc_root,
port=HTTP_PORT,
base_config_path=config_file.name)
GenerateLighttpdConfig(config_file, http_server_doc_root, http_server)
assert http_server.StartupHttpServer()
config_file.close()
# Start QUIC server.
quic_server_doc_root = GenerateQuicTestResources(device)
quic_server = QuicServer(quic_server_doc_root)
quic_server.StartupQuicServer(device)
# Launch Telemetry's benchmark_runner on CronetPerfTestBenchmark.
# By specifying this file's directory as the benchmark directory, it will
# allow benchmark_runner to in turn open this file up and find the
# CronetPerfTestBenchmark class to run the benchmark.
top_level_dir = os.path.dirname(os.path.realpath(__file__))
runner_config = benchmark_runner.ProjectConfig(
top_level_dir=top_level_dir, benchmark_dirs=[top_level_dir])
sys.argv.insert(1, 'run')
sys.argv.insert(2, 'run.CronetPerfTestBenchmark')
sys.argv.insert(3, '--android-rndis')
benchmark_runner.main(runner_config)
# Shutdown.
quic_server.ShutdownQuicServer()
shutil.rmtree(quic_server_doc_root)
http_server.ShutdownHttpServer()
shutil.rmtree(http_server_doc_root)
class ForwardingArgsTest(unittest.TestCase):
port_pairs = forwarders.PortPairs(http=forwarders.PortPair(111, 222),
https=forwarders.PortPair(333, 444),
dns=None)
def testForwardingArgsReverse(self):
forwarding_args = cros_forwarder.CrOsSshForwarder._ForwardingArgs(
use_remote_port_forwarding=True,
host_ip='5.5.5.5',
port_pairs=self.port_pairs)
self.assertEqual(['-R222:5.5.5.5:111', '-R444:5.5.5.5:333'],
forwarding_args)
def testForwardingArgs(self):
forwarding_args = cros_forwarder.CrOsSshForwarder._ForwardingArgs(
use_remote_port_forwarding=False,
host_ip='2.2.2.2',
port_pairs=self.port_pairs)
self.assertEqual(['-L111:2.2.2.2:222', '-L333:2.2.2.2:444'],
forwarding_args)
def GetWprPortPairs(self):
"""Return suitable port pairs to be used for web page replay."""
return forwarders.PortPairs(http=forwarders.PortPair(0, 0),
https=forwarders.PortPair(0, 0),
dns=None)
def __init__(self, http_ports, https_ports, dns_ports):
self.wpr_port_pairs = forwarders.PortPairs(
http=forwarders.PortPair(*http_ports),
https=forwarders.PortPair(*https_ports),
dns=forwarders.PortPair(*dns_ports) if dns_ports else None)
def testConnectionTimeoutRaisesConnectionError(self):
port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80),
https=forwarders.PortPair(8443, 443),
dns=None)
with self.assertRaises(do_nothing_forwarder.ConnectionError):
TestErrorDoNothingForwarder(port_pairs)
def Create(self, port_pairs):
return forwarders.Forwarder(
forwarders.PortPairs(*[
forwarders.PortPair(p.local_port, p.remote_port or p.local_port
) if p else None for p in port_pairs
]))
def SetWprPortPairs(self, http, https, dns):
self.wpr_port_pairs = forwarders.PortPairs(
forwarders.PortPair(*http), forwarders.PortPair(*https),
forwarders.PortPair(*dns) if dns is not None else None)
