def testDefaultPortsMayChange(self):
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(123, 456, 789)
b = self.network_controller_backend
b.Open(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
b.StartReplay('some-archive.wpr')
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(123, 456, 789))
# If replay restarts, use a different set of default ports.
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(987, 654, 321)
b.StartReplay('another-archive.wpr')
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(987, 654, 321))
def testUseSpecificPorts(self):
b = self.network_controller_backend
b.platform_backend.SetWprPortPairs(
http=(88, 8888), https=(44, 4444), dns=None)
b.Open(wpr_modes.WPR_REPLAY, ['--some-arg'])
b.StartReplay('some-archive.wpr')
self.assertEqual(b.replay_server.ports, forwarders.PortSet(88, 44, None))
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(8888, 4444, None))
# Invariant
self.assertEqual(b.forwarder.port_pairs.local_ports, b.replay_server.ports)
self.assertEqual(b.forwarder.port_pairs.remote_ports, b.wpr_device_ports)
def testRestartReplayShouldReusePorts(self):
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(123, 456, 789)
b = self.network_controller_backend
b.Open(wpr_modes.WPR_REPLAY, ['--some-arg'])
b.StartReplay('some-archive.wpr')
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(123, 456, 789))
# If replay restarts, the factory may use a different set of default ports.
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(987, 654, 321)
b.StartReplay('another-archive.wpr')
# However same ports must be used, because apps/browsers may already be
# configured to use the old set of ports.
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(123, 456, 789))
def StartServer(self):
"""Start Web Page Replay and verify that it started.
Returns:
A forwarders.PortSet(http, https, dns) tuple; with dns None if unused.
Raises:
ReplayNotStartedError: if Replay start-up fails.
"""
is_posix = sys.platform.startswith('linux') or sys.platform == 'darwin'
logging.info('Starting Web-Page-Replay: %s', self._cmd_line)
self._CreateTempLogFilePath()
with self._OpenLogFile() as log_fh:
self.replay_process = subprocess.Popen(
self._cmd_line, stdout=log_fh, stderr=subprocess.STDOUT,
preexec_fn=(_ResetInterruptHandler if is_posix else None))
try:
util.WaitFor(self._IsStarted, 30)
atexit_with_log.Register(self.StopServer)
return forwarders.PortSet(
self._started_ports['http'],
self._started_ports['https'],
self._started_ports.get('dns'), # None if unused
)
except exceptions.TimeoutException:
raise ReplayNotStartedError(
'Web Page Replay failed to start. Log output:\n%s' %
''.join(self._LogLines()))
def testNewControllerSessionMayUseDifferentPorts(self):
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(123, 456, 789)
b = self.network_controller_backend
b.Open(wpr_modes.WPR_REPLAY, ['--some-arg'])
b.StartReplay('some-archive.wpr')
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(123, 456, 789))
b.Close()
# If replay restarts, the factory may use a different set of default ports.
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(987, 654, 321)
b.Open(wpr_modes.WPR_REPLAY, ['--some-arg'])
b.StartReplay('some-archive.wpr')
# This time the network controller session was closed between replay's,
# so it's fine to use a different set of ports.
self.assertEqual(b.wpr_device_ports, forwarders.PortSet(987, 654, 321))
def GetWprPortPairs(self):
"""Return suitable port pairs to be used for web page replay."""
default_local_ports = super(CrosPlatformBackend, self).GetWprPortPairs(
).local_ports
return forwarders.PortPairs.Zip(
default_local_ports,
forwarders.PortSet(
http=self.GetRemotePort(default_local_ports.http),
https=self.GetRemotePort(default_local_ports.https),
dns=None))
def __init__(self, archive_path, host_ip, http_port, https_port, dns_port,
replay_args):
self.archive_path = archive_path
self.host_ip = host_ip
self.ports = forwarders.PortSet(
http_port or self.DEFAULT_PORTS.http, https_port
or self.DEFAULT_PORTS.https, dns_port or self.DEFAULT_PORTS.dns
if dns_port is not None else None)
self.replay_args = replay_args
self.is_running = False
def __init__(self, is_replay_active, wpr_http_device_port,
wpr_https_device_port, is_host_platform):
self.is_host_platform = is_host_platform
self.forwarder_factory = mock.Mock()
self.network_controller_backend = mock.Mock()
self.network_controller_backend.is_replay_active = is_replay_active
self.network_controller_backend.wpr_device_ports = forwarders.PortSet(
http=wpr_http_device_port, https=wpr_https_device_port, dns=None)
self.network_controller_backend.host_ip = '127.0.0.1'
self.network_controller_backend.is_test_ca_installed = False
def testSameBrowserUsesSamePorts(self):
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(222, 444, 555)
b = self.network_controller_backend
# Use default ports but no DNS traffic.
b.platform_backend.SetWprPortPairs(http=(0, 0), https=(0, 0), dns=None)
b.SetReplayArgs('some-archive.wpr', wpr_modes.WPR_REPLAY, '3g', [])
b.UpdateReplay(FakeBrowserBackend())
self.assertEqual(b.wpr_device_ports,
forwarders.PortSet(222, 444, None))
# If replay restarts, use a different set of default ports.
FakeReplayServer.DEFAULT_PORTS = forwarders.PortSet(987, 654, 321)
old_replay_server = b.replay_server
b.SetReplayArgs('another-archive.wpr', wpr_modes.WPR_REPLAY, None, [])
b.UpdateReplay() # No browser backend means use the previous one.
# Even though WPR is restarted, it uses the same ports because
# the browser was configured to a particular port set.
self.assertIsNot(b.replay_server, old_replay_server)
self.assertTrue(b.replay_server.is_running)
self.assertFalse(old_replay_server.is_running)
self.assertEqual(b.wpr_device_ports,
forwarders.PortSet(222, 444, None))
def testUseDefaultLocalPorts(self):
b = self.network_controller_backend
b.platform_backend.SetWprPortPairs(http=(0, 8888),
https=(0, 4444),
dns=(0, 2222))
b.Open(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
b.StartReplay('some-archive.wpr')
self.assertEqual(b.replay_server.ports, DEFAULT_PORTS)
self.assertEqual(b.wpr_device_ports,
forwarders.PortSet(8888, 4444, 2222))
# Invariant
self.assertEqual(b.forwarder.port_pairs.local_ports,
b.replay_server.ports)
self.assertEqual(b.forwarder.port_pairs.remote_ports,
b.wpr_device_ports)
# Copyright 2014 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 os
import mock
import unittest
from telemetry.internal import forwarders
from telemetry.internal.platform import network_controller_backend
from telemetry.util import wpr_modes
DEFAULT_PORTS = forwarders.PortSet(http=1111, https=2222, dns=3333)
FORWARDER_HOST_IP = '123.321.123.321'
EXPECTED_WPR_CA_CERT_PATH = os.path.join('[tempdir]', 'testca.pem')
class FakePlatformBackend(object):
def __init__(self):
self.forwarder_factory = FakeForwarderFactory()
self.supports_test_ca = True
self.is_test_ca_installed = False
self.faulty_cert_installer = False
self.wpr_port_pairs = None
# Normally test using all default ports.
self.SetWprPortPairs(http=(0, 0), https=(0, 0), dns=(0, 0))
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)
