| # Copyright 2018 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| r"""Reconnect entry point. |
| |
| Reconnect will: |
| - re-establish ssh tunnels for adb/vnc port forwarding for a remote instance |
| - adb connect to forwarded ssh port for remote instance |
| - restart vnc for remote/local instances |
| """ |
| |
| import logging |
| import os |
| import re |
| |
| from acloud import errors |
| from acloud.internal import constants |
| from acloud.internal.lib import auth |
| from acloud.internal.lib import android_compute_client |
| from acloud.internal.lib import cvd_runtime_config |
| from acloud.internal.lib import gcompute_client |
| from acloud.internal.lib import utils |
| from acloud.internal.lib import ssh as ssh_object |
| from acloud.internal.lib.adb_tools import AdbTools |
| from acloud.list import list as list_instance |
| from acloud.public import config |
| from acloud.public import report |
| |
| |
| logger = logging.getLogger(__name__) |
| |
| _RE_DISPLAY = re.compile(r"([\d]+)x([\d]+)\s.*") |
| _VNC_STARTED_PATTERN = "ssvnc vnc://127.0.0.1:%(vnc_port)d" |
| |
| |
| def _IsWebrtcEnable(instance, host_user, host_ssh_private_key_path, |
| extra_args_ssh_tunnel): |
| """Check local/remote instance webRTC is enable. |
| |
| Args: |
| instance: Local/Remote Instance object. |
| host_user: String of user login into the instance. |
| host_ssh_private_key_path: String of host key for logging in to the |
| host. |
| extra_args_ssh_tunnel: String, extra args for ssh tunnel connection. |
| |
| Returns: |
| Boolean: True if cf_runtime_cfg.enable_webrtc is True. |
| """ |
| if instance.islocal: |
| return instance.cf_runtime_cfg.enable_webrtc |
| ssh = ssh_object.Ssh(ip=ssh_object.IP(ip=instance.ip), user=host_user, |
| ssh_private_key_path=host_ssh_private_key_path, |
| extra_args_ssh_tunnel=extra_args_ssh_tunnel) |
| remote_cuttlefish_config = os.path.join(constants.REMOTE_LOG_FOLDER, |
| constants.CUTTLEFISH_CONFIG_FILE) |
| raw_data = ssh.GetCmdOutput("cat " + remote_cuttlefish_config) |
| try: |
| cf_runtime_cfg = cvd_runtime_config.CvdRuntimeConfig( |
| raw_data=raw_data.strip()) |
| return cf_runtime_cfg.enable_webrtc |
| except errors.ConfigError: |
| logger.debug("No cuttlefish config[%s] found!", |
| remote_cuttlefish_config) |
| return False |
| |
| |
| def StartVnc(vnc_port, display): |
| """Start vnc connect to AVD. |
| |
| Confirm whether there is already a connection before VNC connection. |
| If there is a connection, it will not be connected. If not, connect it. |
| Before reconnecting, clear old disconnect ssvnc viewer. |
| |
| Args: |
| vnc_port: Integer of vnc port number. |
| display: String, vnc connection resolution. e.g., 1080x720 (240) |
| """ |
| vnc_started_pattern = _VNC_STARTED_PATTERN % {"vnc_port": vnc_port} |
| if not utils.IsCommandRunning(vnc_started_pattern): |
| #clean old disconnect ssvnc viewer. |
| utils.CleanupSSVncviewer(vnc_port) |
| |
| match = _RE_DISPLAY.match(display) |
| if match: |
| utils.LaunchVncClient(vnc_port, match.group(1), match.group(2)) |
| else: |
| utils.LaunchVncClient(vnc_port) |
| |
| |
| def AddPublicSshRsaToInstance(cfg, user, instance_name): |
| """Add the public rsa key to the instance's metadata. |
| |
| When the public key doesn't exist in the metadata, it will add it. |
| |
| Args: |
| cfg: An AcloudConfig instance. |
| user: String, the ssh username to access instance. |
| instance_name: String, instance name. |
| """ |
| credentials = auth.CreateCredentials(cfg) |
| compute_client = android_compute_client.AndroidComputeClient( |
| cfg, credentials) |
| compute_client.AddSshRsaInstanceMetadata( |
| user, |
| cfg.ssh_public_key_path, |
| instance_name) |
| |
| |
| @utils.TimeExecute(function_description="Reconnect instances") |
| def ReconnectInstance(ssh_private_key_path, |
| instance, |
| reconnect_report, |
| extra_args_ssh_tunnel=None, |
| autoconnect=None, |
| connect_hostname=None): |
| """Reconnect to the specified instance. |
| |
| It will: |
| - re-establish ssh tunnels for adb/vnc port forwarding |
| - re-establish adb connection |
| - restart vnc client |
| - update device information in reconnect_report |
| |
| Args: |
| ssh_private_key_path: Path to the private key file. |
| e.g. ~/.ssh/acloud_rsa |
| instance: list.Instance() object. |
| reconnect_report: Report object. |
| extra_args_ssh_tunnel: String, extra args for ssh tunnel connection. |
| autoconnect: String, for decide whether to launch vnc/browser or not. |
| connect_hostname: String, the hostname for ssh connect. |
| |
| Raises: |
| errors.UnknownAvdType: Unable to reconnect to instance of unknown avd |
| type. |
| """ |
| if instance.avd_type not in utils.AVD_PORT_DICT: |
| raise errors.UnknownAvdType("Unable to reconnect to instance (%s) of " |
| "unknown avd type: %s" % |
| (instance.name, instance.avd_type)) |
| # Ignore extra ssh tunnel to connect with hostname. |
| if connect_hostname: |
| extra_args_ssh_tunnel = None |
| |
| adb_cmd = AdbTools(instance.adb_port) |
| vnc_port = instance.vnc_port |
| adb_port = instance.adb_port |
| webrtc_port = instance.webrtc_port |
| # ssh tunnel is up but device is disconnected on adb |
| if instance.ssh_tunnel_is_connected and not adb_cmd.IsAdbConnectionAlive(): |
| adb_cmd.DisconnectAdb() |
| adb_cmd.ConnectAdb() |
| # ssh tunnel is down and it's a remote instance |
| elif not instance.ssh_tunnel_is_connected and not instance.islocal: |
| adb_cmd.DisconnectAdb() |
| forwarded_ports = utils.AutoConnect( |
| ip_addr=connect_hostname or instance.ip, |
| rsa_key_file=ssh_private_key_path, |
| target_vnc_port=utils.AVD_PORT_DICT[instance.avd_type].vnc_port, |
| target_adb_port=utils.AVD_PORT_DICT[instance.avd_type].adb_port, |
| ssh_user=constants.GCE_USER, |
| extra_args_ssh_tunnel=extra_args_ssh_tunnel) |
| vnc_port = forwarded_ports.vnc_port |
| adb_port = forwarded_ports.adb_port |
| if autoconnect is constants.INS_KEY_WEBRTC: |
| if not instance.islocal: |
| webrtc_port = utils.GetWebrtcPortFromSSHTunnel(instance.ip) |
| if not webrtc_port: |
| webrtc_port = utils.PickFreePort() |
| utils.EstablishWebRTCSshTunnel( |
| ip_addr=connect_hostname or instance.ip, |
| webrtc_local_port=webrtc_port, |
| rsa_key_file=ssh_private_key_path, |
| ssh_user=constants.GCE_USER, |
| extra_args_ssh_tunnel=extra_args_ssh_tunnel) |
| utils.LaunchBrowser(constants.WEBRTC_LOCAL_HOST, |
| webrtc_port) |
| elif vnc_port and autoconnect is constants.INS_KEY_VNC: |
| StartVnc(vnc_port, instance.display) |
| |
| device_dict = { |
| constants.IP: instance.ip, |
| constants.INSTANCE_NAME: instance.name, |
| constants.VNC_PORT: vnc_port, |
| constants.ADB_PORT: adb_port |
| } |
| if adb_port and not instance.islocal: |
| device_dict[constants.DEVICE_SERIAL] = ( |
| constants.REMOTE_INSTANCE_ADB_SERIAL % adb_port) |
| |
| if (vnc_port or webrtc_port) and adb_port: |
| reconnect_report.AddData(key="devices", value=device_dict) |
| else: |
| # We use 'ps aux' to grep adb/vnc fowarding port from ssh tunnel |
| # command. Therefore we report failure here if no vnc_port and |
| # adb_port found. |
| reconnect_report.AddData(key="device_failing_reconnect", value=device_dict) |
| reconnect_report.AddError(instance.name) |
| |
| |
| def GetSshConnectHostname(cfg, instance): |
| """Get ssh connect hostname. |
| |
| Get GCE hostname with specific rule for cloudtop users. |
| |
| Args: |
| cfg: AcloudConfig object. |
| instance: list.Instance() object. |
| |
| Returns: |
| String of hostname for ssh connect. None is for not connect with |
| hostname such as local instance mode. |
| """ |
| if instance.islocal: |
| return None |
| if cfg.connect_hostname: |
| return gcompute_client.GetGCEHostName( |
| cfg.project, instance.name, cfg.zone) |
| return None |
| |
| |
| def Run(args): |
| """Run reconnect. |
| |
| Args: |
| args: Namespace object from argparse.parse_args. |
| """ |
| cfg = config.GetAcloudConfig(args) |
| instances_to_reconnect = [] |
| if args.instance_names is not None: |
| # user input instance name to get instance object. |
| instances_to_reconnect = list_instance.GetInstancesFromInstanceNames( |
| cfg, args.instance_names) |
| if not instances_to_reconnect: |
| instances_to_reconnect = list_instance.ChooseInstances(cfg, args.all) |
| |
| reconnect_report = report.Report(command="reconnect") |
| for instance in instances_to_reconnect: |
| if instance.avd_type not in utils.AVD_PORT_DICT: |
| utils.PrintColorString("Skipping reconnect of instance %s due to " |
| "unknown avd type (%s)." % |
| (instance.name, instance.avd_type), |
| utils.TextColors.WARNING) |
| continue |
| if not instance.islocal: |
| AddPublicSshRsaToInstance(cfg, constants.GCE_USER, instance.name) |
| ReconnectInstance(cfg.ssh_private_key_path, |
| instance, |
| reconnect_report, |
| cfg.extra_args_ssh_tunnel, |
| autoconnect=(args.autoconnect or instance.autoconnect), |
| connect_hostname=GetSshConnectHostname(cfg, instance)) |
| |
| utils.PrintDeviceSummary(reconnect_report) |
