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()