def _GetDevToolsClientConfig(self):
# TODO(crbug.com/787834): Split into reading DevToolsActivePort, retrying
# if needed, and setting up fowarder.
try:
file_content = self._cri.GetFileContents(self.devtools_file_path)
except (IOError, OSError):
return False
if len(file_content) == 0:
return False
port_target = file_content.split('\n')
remote_port = int(port_target[0])
# Use _remote_debugging_port for _port for now (local telemetry case)
# Override it with the forwarded port below for the remote telemetry case.
local_port = remote_port
if len(port_target) > 1 and port_target[1]:
browser_target = port_target[1]
logging.info('Discovered ephemeral port %s', local_port)
logging.info('Browser target: %s', browser_target)
# TODO(#1977): Can simplify using local forwarding and default ports.
if not self._cri.local:
local_port = util.GetUnreservedAvailableLocalPort()
self._forwarder = self._platform_backend.forwarder_factory.Create(
local_port=local_port, remote_port=remote_port, reverse=True)
return devtools_client_backend.DevToolsClientConfig(
local_port=local_port,
remote_port=remote_port,
browser_target=browser_target,
app_backend=self)
def GetBrowserStartupArgs(self):
args = super(DesktopMandolineBackend, self).GetBrowserStartupArgs()
self._port = util.GetUnreservedAvailableLocalPort()
logging.info('Requested remote debugging port: %d' % self._port)
args.append('--remote-debugging-port=%i' % self._port)
args.append('--user-data-dir=%s' % self.profile_directory)
return args
def HasBrowserFinishedLaunching(self):
try:
file_content = self._cri.GetFileContents(self.devtools_file_path)
except (IOError, OSError):
return False
if len(file_content) == 0:
return False
port_target = file_content.split('\n')
self._remote_debugging_port = int(port_target[0])
# Use _remote_debugging_port for _port for now (local telemetry case)
# Override it with the forwarded port below for the remote telemetry case.
self._port = self._remote_debugging_port
if len(port_target) > 1 and port_target[1]:
self._browser_target = port_target[1]
logging.info('Discovered ephemeral port %s', self._port)
logging.info('Browser target: %s', self._browser_target)
# TODO(#1977): Simplify when cross forwarder supports missing local ports.
if not self._cri.local:
self._port = util.GetUnreservedAvailableLocalPort()
self._forwarder = self._platform_backend.forwarder_factory.Create(
local_port=self._port, remote_port=self._remote_debugging_port,
reverse=True)
return super(CrOSBrowserBackend, self).HasBrowserFinishedLaunching()
def __init__(self, cri, local_port, remote_port, port_forward):
super(CrOsSshForwarder, self).__init__()
self._cri = cri
self._proc = None
if port_forward:
assert local_port, 'Local port must be given'
else:
assert remote_port, 'Remote port must be given'
if not local_port:
# Choose an available port on the host.
local_port = util.GetUnreservedAvailableLocalPort()
forwarding_args = _ForwardingArgs(local_port, remote_port,
self.host_ip, port_forward)
# TODO(crbug.com/793256): Consider avoiding the extra tempfile and
# read stderr directly from the subprocess instead.
with tempfile.NamedTemporaryFile() as stderr_file:
self._proc = subprocess.Popen(self._cri.FormSSHCommandLine(
['-NT'], forwarding_args, port_forward=port_forward),
stdout=subprocess.PIPE,
stderr=stderr_file,
stdin=subprocess.PIPE,
shell=False)
if not remote_port:
remote_port = _ReadRemotePort(stderr_file.name)
self._StartedForwarding(local_port, remote_port)
py_utils.WaitFor(self._IsConnectionReady, timeout=60)
def HasBrowserFinishedLaunching(self):
try:
file_content = self._cri.GetFileContents(self.devtools_file_path)
except (IOError, OSError):
return False
if len(file_content) == 0:
return False
port_target = file_content.split('\n')
self._remote_debugging_port = int(port_target[0])
# Use _remote_debugging_port for _port for now (local telemetry case)
# Override it with the forwarded port below for the remote telemetry case.
self._port = self._remote_debugging_port
if len(port_target) > 1 and port_target[1]:
self._browser_target = port_target[1]
logging.info('Discovered ephemeral port %s', self._port)
logging.info('Browser target: %s', self._browser_target)
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.PortPair(self._port, self._remote_debugging_port),
use_remote_port_forwarding=False)
return super(CrOSBrowserBackend, self).HasBrowserFinishedLaunching()
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:
self._port = util.GetUnreservedAvailableLocalPort()
self._forwarder = self.forwarder_factory.Create(
forwarders.PortPairs(http=forwarders.PortPair(
self._port, self._remote_debugging_port),
https=None,
dns=None),
forwarding_flag='L')
try:
self._WaitForBrowserToComeUp(wait_for_extensions=False)
self._PostBrowserStartupInitialization()
except:
import traceback
traceback.print_exc()
self.Close()
raise
# chrome_branch_number is set in _PostBrowserStartupInitialization.
# Without --skip-hwid-check (introduced in crrev.com/203397), devices/VMs
# will be stuck on the bad hwid screen.
if self.chrome_branch_number <= 1500 and not self.hwid:
raise exceptions.LoginException(
'Hardware id not set on device/VM. --skip-hwid-check not supported '
'with chrome branches 1500 or earlier.')
util.WaitFor(lambda: self.oobe_exists, 10)
if self.browser_options.auto_login:
if self._is_guest:
pid = self.pid
self._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)
self._WaitForBrowserToComeUp()
else:
self._NavigateLogin()
logging.info('Browser is up!')
def __init__(self, device, local_port, remote_port):
super(AndroidReverseForwarder, self).__init__()
self._device = device
assert remote_port, 'Remote port must be given'
if not local_port:
local_port = util.GetUnreservedAvailableLocalPort()
self._device.adb.Forward('tcp:%d' % local_port, remote_port)
self._StartedForwarding(local_port, remote_port)
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 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.
pid = self.pid
logging.info('Restarting Chrome (pid=%d) with remote port', pid)
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)]
logging.info('Starting Chrome %s', 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.PortPair(self._port, self._remote_debugging_port),
use_remote_port_forwarding=False)
# Wait for new chrome and oobe.
py_utils.WaitFor(lambda: pid != self.pid, 15)
self._WaitForBrowserToComeUp()
self._InitDevtoolsClientBackend(
remote_devtools_port=self._remote_debugging_port)
py_utils.WaitFor(lambda: self.oobe_exists, 30)
if self.browser_options.auto_login:
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.
try:
# TODO(achuith): Reduce this timeout to 15 sec after crbug.com/631640
# is resolved.
py_utils.WaitFor(lambda: pid != self.pid, 60)
except py_utils.TimeoutException:
self._RaiseOnLoginFailure(
'Failed to restart browser in guest mode (pid %d).' % pid)
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)
try:
self._WaitForLogin()
except py_utils.TimeoutException:
self._RaiseOnLoginFailure('Timed out going through login screen. '
+ self._GetLoginStatus())
logging.info('Browser is up!')
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:
self._port = util.GetUnreservedAvailableLocalPort()
self._forwarder = self.forwarder_factory.Create(
forwarders.PortPairs(http=forwarders.PortPair(
self._port, self._remote_debugging_port),
https=None,
dns=None),
forwarding_flag='L')
try:
self._WaitForBrowserToComeUp(wait_for_extensions=False)
self._PostBrowserStartupInitialization()
except:
import traceback
traceback.print_exc()
self.Close()
raise
util.WaitFor(lambda: self.oobe_exists, 10)
if self.browser_options.auto_login:
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:
try:
self.oobe.NavigateGaiaLogin(self._username, self._password)
except util.TimeoutException:
self._cri.TakeScreenShot('gaia-login')
raise
else:
self.oobe.NavigateFakeLogin(self._username, self._password)
self._WaitForLogin()
logging.info('Browser is up!')
def __init__(self, device, port_pair):
super(AndroidReverseForwarder, self).__init__(port_pair)
self._device = device
local_port, remote_port = port_pair
assert remote_port, 'Remote port must be given'
if not local_port:
local_port = util.GetUnreservedAvailableLocalPort()
self._device.adb.Forward('tcp:%d' % local_port, remote_port)
self._port_pair = forwarders.PortPair(local_port, remote_port)
def GetBrowserStartupArgs(self):
args = super(DesktopMandolineBackend, self).GetBrowserStartupArgs()
if self.browser_options.use_devtools_active_port:
raise NotImplementedError()
else:
self._port = util.GetUnreservedAvailableLocalPort()
logging.info('Requested remote debugging port: %d' % self._port)
args.append('--remote-debugging-port=%i' % self._port)
return args
def GetBrowserStartupArgs(self):
args = super(DesktopBrowserBackend, self).GetBrowserStartupArgs()
self._port = util.GetUnreservedAvailableLocalPort()
args.append('--remote-debugging-port=%i' % self._port)
args.append('--enable-crash-reporter-for-testing')
if not self.is_content_shell:
args.append('--window-size=1280,1024')
if self._flash_path:
args.append('--ppapi-flash-path=%s' % self._flash_path)
if not self.browser_options.dont_override_profile:
args.append('--user-data-dir=%s' % self._tmp_profile_dir)
return args
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 Start(self):
self.device.RunShellCommand('logcat -c')
self.platform_backend.DismissCrashDialogIfNeeded()
self._port = util.GetUnreservedAvailableLocalPort()
self._device_port = self._GetAvailableDevicePort()
self.device.adb.Forward('tcp:%d' % self._port,
'tcp:%d' % self._device_port)
logging.info('Forwarded host port %d to device port %d.' %
(self._port, self._device_port))
args = self.GetBrowserStartupArgs()
if self.browser_options.startup_url:
args.append(self.browser_options.startup_url)
logging.debug('Starting Mandoline %s', args)
is_debug = 'debug' in self._browser_type
mandoline_config = config.Config(build_dir=self._build_path,
target_os=config.Config.OS_ANDROID,
target_cpu=self._target_arch,
is_debug=is_debug,
apk_name='Mandoline.apk')
shell = android.AndroidShell(mandoline_config, self._chrome_root)
shell.InitShell(self.device)
output = sys.stdout
if not self.browser_options.show_stdout:
output = open(os.devnull, 'w')
logging_process = shell.ShowLogs(output)
# Unlock device screen.
self.device.SendKeyEvent(keyevent.KEYCODE_MENU)
shell.StartActivity(self.activity, args, output,
logging_process.terminate)
try:
self._WaitForBrowserToComeUp()
self._InitDevtoolsClientBackend(self._port)
except exceptions.BrowserGoneException:
logging.critical('Failed to connect to browser.')
self.Close()
raise
except:
self.Close()
raise
def GetBrowserStartupArgs(self):
args = super(DesktopBrowserBackend, self).GetBrowserStartupArgs()
if self.browser_options.use_devtools_active_port:
self._port = 0
else:
self._port = util.GetUnreservedAvailableLocalPort()
logging.info('Requested remote debugging port: %d' % self._port)
args.append('--remote-debugging-port=%i' % self._port)
args.append('--enable-crash-reporter-for-testing')
args.append('--use-mock-keychain')
if not self._is_content_shell:
args.append('--window-size=1280,1024')
if self._flash_path:
args.append('--ppapi-flash-path=%s' % self._flash_path)
if not self.browser_options.dont_override_profile:
args.append('--user-data-dir=%s' % self._tmp_profile_dir)
return args
def StartMonitoringPower(self, browser):
assert not self._ippet_handle, 'Called StartMonitoringPower() twice.'
self._output_dir = tempfile.mkdtemp()
self._ippet_port = util.GetUnreservedAvailableLocalPort()
parameters = [
'-log_dir', self._output_dir, '-web_port',
str(self._ippet_port), '-zip', 'n'
]
self._ippet_handle = self._backend.LaunchApplication(
IppetPath(), parameters, elevate_privilege=True)
def IppetServerIsUp():
try:
urllib2.urlopen('http://127.0.0.1:%d/ippet' % self._ippet_port,
timeout=1).close()
except urllib2.URLError:
return False
return True
util.WaitFor(IppetServerIsUp, timeout=5)
def _StartMsrServerIfNeeded(self):
if self._msr_server_handle:
return
_InstallWinRing0()
self._msr_server_port = util.GetUnreservedAvailableLocalPort()
# It might be flaky to get a port number without reserving it atomically,
# but if the server process chooses a port, we have no way of getting it.
# The stdout of the elevated process isn't accessible.
parameters = (
os.path.join(os.path.dirname(__file__), 'msr_server_win.py'),
str(self._msr_server_port),
)
self._msr_server_handle = self.LaunchApplication(
sys.executable, parameters, elevate_privilege=True)
# Wait for server to start.
try:
socket.create_connection(('127.0.0.1', self._msr_server_port), 5).close()
except socket.error:
self.CloseMsrServer()
atexit.register(TerminateProcess, self._msr_server_handle)
def __init__(self, local_port, remote_port, command_runner, port_forward):
"""Sets up ssh port forwarding betweeen a Fuchsia device and the host.
Args:
local_port: Port on the host.
remote_port: Port on the Fuchsia device.
command_runner: Contains information related to ssh configuration.
port_forward: Determines the direction of the connection."""
super(FuchsiaSshForwarder, self).__init__()
self._proc = None
if port_forward:
assert local_port, 'Local port must be given'
else:
assert remote_port, 'Remote port must be given'
if not local_port:
# Choose an available port on the host.
local_port = util.GetUnreservedAvailableLocalPort()
ssh_args = [
'-N', # Don't execute command
'-T' # Don't allocate terminal.
# Ensure SSH is at least verbose enough to print the allocated port
'-o',
'LogLevel=VERBOSE'
]
ssh_args.extend(
forwarder_utils.GetForwardingArgs(local_port, remote_port,
self.host_ip, port_forward))
with tempfile.NamedTemporaryFile() as stderr_file:
self._proc = command_runner.RunCommandPiped(ssh_args=ssh_args,
stderr=stderr_file)
if not remote_port:
remote_port = forwarder_utils.ReadRemotePort(stderr_file.name)
self._StartedForwarding(local_port, remote_port)
def __init__(self, local_port, remote_port, command_runner, port_forward):
"""Sets up ssh port forwarding betweeen a Fuchsia device and the host.
Args:
local_port: Port on the host.
remote_port: Port on the Fuchsia device.
command_runner: Contains information related to ssh configuration.
port_forward: Determines the direction of the connection."""
super(FuchsiaSshForwarder, self).__init__()
self._proc = None
if port_forward:
assert local_port, 'Local port must be given'
else:
assert remote_port, 'Remote port must be given'
if not local_port:
# Choose an available port on the host.
local_port = util.GetUnreservedAvailableLocalPort()
forward_cmd = [
'-O',
'forward', # Send SSH mux control signal.
'-N', # Don't execute command
'-T' # Don't allocate terminal.
]
forward_cmd.append(
forwarder_utils.GetForwardingArgs(local_port, remote_port,
self.host_ip, port_forward))
with tempfile.NamedTemporaryFile() as stderr_file:
self._proc = command_runner.RunCommandPiped(forward_cmd,
stderr=stderr_file)
if not remote_port:
remote_port = forwarder_utils.ReadRemotePort(stderr_file.name)
self._StartedForwarding(local_port, remote_port)
def GetRemotePort(self, _):
return util.GetUnreservedAvailableLocalPort()
