| # 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"""Instance class. |
| |
| Define the instance class used to hold details about an AVD instance. |
| |
| The instance class will hold details about AVD instances (remote/local) used to |
| enable users to understand what instances they've created. This will be leveraged |
| for the list, delete, and reconnect commands. |
| |
| The details include: |
| - instance name (for remote instances) |
| - creation date/instance duration |
| - instance image details (branch/target/build id) |
| - and more! |
| """ |
| |
| import datetime |
| import logging |
| import re |
| import subprocess |
| |
| # pylint: disable=import-error |
| import dateutil.parser |
| import dateutil.tz |
| |
| from acloud.internal import constants |
| from acloud.internal.lib import utils |
| from acloud.internal.lib.adb_tools import AdbTools |
| |
| logger = logging.getLogger(__name__) |
| |
| _MSG_UNABLE_TO_CALCULATE = "Unable to calculate" |
| _RE_GROUP_ADB = "local_adb_port" |
| _RE_GROUP_VNC = "local_vnc_port" |
| _RE_SSH_TUNNEL_PATTERN = (r"((.*\s*-L\s)(?P<%s>\d+):127.0.0.1:%s)" |
| r"((.*\s*-L\s)(?P<%s>\d+):127.0.0.1:%s)" |
| r"(.+%s)") |
| _RE_TIMEZONE = re.compile(r"^(?P<time>[0-9\-\.:T]*)(?P<timezone>[+-]\d+:\d+)$") |
| |
| _COMMAND_PS_LAUNCH_CVD = ["ps", "-wweo", "lstart,cmd"] |
| _RE_LAUNCH_CVD = re.compile(r"(?P<date_str>^[^/]+)(.*launch_cvd --daemon )+" |
| r"((.*\s*-cpus\s)(?P<cpu>\d+))?" |
| r"((.*\s*-x_res\s)(?P<x_res>\d+))?" |
| r"((.*\s*-y_res\s)(?P<y_res>\d+))?" |
| r"((.*\s*-dpi\s)(?P<dpi>\d+))?" |
| r"((.*\s*-memory_mb\s)(?P<memory>\d+))?" |
| r"((.*\s*-blank_data_image_mb\s)(?P<disk>\d+))?") |
| _FULL_NAME_STRING = ("device serial: %(device_serial)s (%(instance_name)s) " |
| "elapsed time: %(elapsed_time)s") |
| |
| |
| def _GetElapsedTime(start_time): |
| """Calculate the elapsed time from start_time till now. |
| |
| Args: |
| start_time: String of instance created time. |
| |
| Returns: |
| datetime.timedelta of elapsed time, _MSG_UNABLE_TO_CALCULATE for |
| datetime can't parse cases. |
| """ |
| match = _RE_TIMEZONE.match(start_time) |
| try: |
| # Check start_time has timezone or not. If timezone can't be found, |
| # use local timezone to get elapsed time. |
| if match: |
| return datetime.datetime.now( |
| dateutil.tz.tzlocal()) - dateutil.parser.parse(start_time) |
| |
| return datetime.datetime.now( |
| dateutil.tz.tzlocal()) - dateutil.parser.parse( |
| start_time).replace(tzinfo=dateutil.tz.tzlocal()) |
| except ValueError: |
| logger.debug(("Can't parse datetime string(%s)."), start_time) |
| return _MSG_UNABLE_TO_CALCULATE |
| |
| |
| class Instance(object): |
| """Class to store data of instance.""" |
| |
| def __init__(self): |
| self._name = None |
| self._fullname = None |
| self._status = None |
| self._display = None # Resolution and dpi |
| self._ip = None |
| self._adb_port = None # adb port which is forwarding to remote |
| self._vnc_port = None # vnc port which is forwarding to remote |
| self._ssh_tunnel_is_connected = None # True if ssh tunnel is still connected |
| self._createtime = None |
| self._elapsed_time = None |
| self._avd_type = None |
| self._avd_flavor = None |
| self._is_local = None # True if this is a local instance |
| |
| def __repr__(self): |
| """Return full name property for print.""" |
| return self._fullname |
| |
| def Summary(self): |
| """Let's make it easy to see what this class is holding.""" |
| indent = " " * 3 |
| representation = [] |
| representation.append(" name: %s" % self._name) |
| representation.append("%s IP: %s" % (indent, self._ip)) |
| representation.append("%s create time: %s" % (indent, self._createtime)) |
| representation.append("%s elapse time: %s" % (indent, self._elapsed_time)) |
| representation.append("%s status: %s" % (indent, self._status)) |
| representation.append("%s avd type: %s" % (indent, self._avd_type)) |
| representation.append("%s display: %s" % (indent, self._display)) |
| representation.append("%s vnc: 127.0.0.1:%s" % (indent, self._vnc_port)) |
| |
| if self._adb_port: |
| representation.append("%s adb serial: 127.0.0.1:%s" % |
| (indent, self._adb_port)) |
| else: |
| representation.append("%s adb serial: disconnected" % indent) |
| |
| return "\n".join(representation) |
| |
| @property |
| def name(self): |
| """Return the instance name.""" |
| return self._name |
| |
| @property |
| def fullname(self): |
| """Return the instance full name.""" |
| return self._fullname |
| |
| @property |
| def ip(self): |
| """Return the ip.""" |
| return self._ip |
| |
| @property |
| def status(self): |
| """Return status.""" |
| return self._status |
| |
| @property |
| def display(self): |
| """Return display.""" |
| return self._display |
| |
| @property |
| def forwarding_adb_port(self): |
| """Return the adb port.""" |
| return self._adb_port |
| |
| @property |
| def forwarding_vnc_port(self): |
| """Return the vnc port.""" |
| return self._vnc_port |
| |
| @property |
| def ssh_tunnel_is_connected(self): |
| """Return the connect status.""" |
| return self._ssh_tunnel_is_connected |
| |
| @property |
| def createtime(self): |
| """Return create time.""" |
| return self._createtime |
| |
| @property |
| def avd_type(self): |
| """Return avd_type.""" |
| return self._avd_type |
| |
| @property |
| def avd_flavor(self): |
| """Return avd_flavor.""" |
| return self._avd_flavor |
| |
| @property |
| def islocal(self): |
| """Return if it is a local instance.""" |
| return self._is_local |
| |
| |
| class LocalInstance(Instance): |
| """Class to store data of local instance.""" |
| |
| # pylint: disable=protected-access |
| def __new__(cls): |
| """Initialize a localInstance object. |
| |
| Gather local instance information from launch_cvd process. |
| |
| returns: |
| Instance object if launch_cvd process is found otherwise return None. |
| """ |
| # Running instances on local is not supported on all OS. |
| if not utils.IsSupportedPlatform(): |
| return None |
| |
| process_output = subprocess.check_output(_COMMAND_PS_LAUNCH_CVD) |
| for line in process_output.splitlines(): |
| match = _RE_LAUNCH_CVD.match(line) |
| if match: |
| local_instance = Instance() |
| x_res = match.group("x_res") |
| y_res = match.group("y_res") |
| dpi = match.group("dpi") |
| date_str = match.group("date_str").strip() |
| local_instance._name = constants.LOCAL_INS_NAME |
| local_instance._createtime = date_str |
| local_instance._elapsed_time = _GetElapsedTime(date_str) |
| local_instance._fullname = (_FULL_NAME_STRING % |
| {"device_serial": "127.0.0.1:%d" % |
| constants.CF_ADB_PORT, |
| "instance_name": local_instance._name, |
| "elapsed_time": local_instance._elapsed_time}) |
| local_instance._avd_type = constants.TYPE_CF |
| local_instance._ip = "127.0.0.1" |
| local_instance._status = constants.INS_STATUS_RUNNING |
| local_instance._adb_port = constants.CF_ADB_PORT |
| local_instance._vnc_port = constants.CF_VNC_PORT |
| local_instance._display = ("%sx%s (%s)" % (x_res, y_res, dpi)) |
| local_instance._is_local = True |
| local_instance._ssh_tunnel_is_connected = True |
| return local_instance |
| return None |
| |
| |
| class RemoteInstance(Instance): |
| """Class to store data of remote instance.""" |
| |
| def __init__(self, gce_instance): |
| """Process the args into class vars. |
| |
| RemoteInstace initialized by gce dict object. |
| Reference: |
| https://cloud.google.com/compute/docs/reference/rest/v1/instances/get |
| |
| Args: |
| gce_instance: dict object queried from gce. |
| """ |
| super(RemoteInstance, self).__init__() |
| self._ProcessGceInstance(gce_instance) |
| self._is_local = False |
| |
| def _ProcessGceInstance(self, gce_instance): |
| """Parse the required data from gce_instance to local variables. |
| |
| We also gather more details on client side including the forwarding adb |
| port and vnc port which will be used to determine the status of ssh |
| tunnel connection. |
| |
| The status of gce instance will be displayed in _fullname property: |
| - Connected: If gce instance and ssh tunnel and adb connection are all |
| active. |
| - No connected: If ssh tunnel or adb connection is not found. |
| - Terminated: If we can't retrieve the public ip from gce instance. |
| |
| Args: |
| gce_instance: dict object queried from gce. |
| """ |
| self._name = gce_instance.get(constants.INS_KEY_NAME) |
| |
| self._createtime = gce_instance.get(constants.INS_KEY_CREATETIME) |
| self._elapsed_time = _GetElapsedTime(self._createtime) |
| self._status = gce_instance.get(constants.INS_KEY_STATUS) |
| |
| ip = None |
| for network_interface in gce_instance.get("networkInterfaces"): |
| for access_config in network_interface.get("accessConfigs"): |
| ip = access_config.get("natIP") |
| |
| # Get metadata |
| for metadata in gce_instance.get("metadata", {}).get("items", []): |
| key = metadata["key"] |
| value = metadata["value"] |
| if key == constants.INS_KEY_DISPLAY: |
| self._display = value |
| elif key == constants.INS_KEY_AVD_TYPE: |
| self._avd_type = value |
| elif key == constants.INS_KEY_AVD_FLAVOR: |
| self._avd_flavor = value |
| |
| # Find ssl tunnel info. |
| if ip: |
| forwarded_ports = self.GetAdbVncPortFromSSHTunnel(ip, |
| self._avd_type) |
| self._ip = ip |
| self._adb_port = forwarded_ports.adb_port |
| self._vnc_port = forwarded_ports.vnc_port |
| self._ssh_tunnel_is_connected = self._adb_port is not None |
| |
| adb_device = AdbTools(self._adb_port) |
| if adb_device.IsAdbConnected(): |
| self._fullname = (_FULL_NAME_STRING % |
| {"device_serial": "127.0.0.1:%d" % self._adb_port, |
| "instance_name": self._name, |
| "elapsed_time": self._elapsed_time}) |
| else: |
| self._fullname = (_FULL_NAME_STRING % |
| {"device_serial": "not connected", |
| "instance_name": self._name, |
| "elapsed_time": self._elapsed_time}) |
| # If instance is terminated, its ip is None. |
| else: |
| self._ssh_tunnel_is_connected = False |
| self._fullname = (_FULL_NAME_STRING % |
| {"device_serial": "terminated", |
| "instance_name": self._name, |
| "elapsed_time": self._elapsed_time}) |
| |
| @staticmethod |
| def GetAdbVncPortFromSSHTunnel(ip, avd_type): |
| """Get forwarding adb and vnc port from ssh tunnel. |
| |
| Args: |
| ip: String, ip address. |
| avd_type: String, the AVD type. |
| |
| Returns: |
| NamedTuple ForwardedPorts(vnc_port, adb_port) holding the ports |
| used in the ssh forwarded call. Both fields are integers. |
| """ |
| process_output = subprocess.check_output(constants.COMMAND_PS) |
| default_vnc_port = utils.AVD_PORT_DICT[avd_type].vnc_port |
| default_adb_port = utils.AVD_PORT_DICT[avd_type].adb_port |
| re_pattern = re.compile(_RE_SSH_TUNNEL_PATTERN % |
| (_RE_GROUP_VNC, default_vnc_port, |
| _RE_GROUP_ADB, default_adb_port, ip)) |
| |
| adb_port = None |
| vnc_port = None |
| for line in process_output.splitlines(): |
| match = re_pattern.match(line) |
| if match: |
| adb_port = int(match.group(_RE_GROUP_ADB)) |
| vnc_port = int(match.group(_RE_GROUP_VNC)) |
| break |
| |
| logger.debug(("grathering detail for ssh tunnel. " |
| "IP:%s, forwarding (adb:%d, vnc:%d)"), ip, adb_port, |
| vnc_port) |
| |
| return utils.ForwardedPorts(vnc_port=vnc_port, adb_port=adb_port) |
