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