Merge "Cert: Wait for root server to start using future" am: 26e73da0ae (4ae0f5fb) · Commits · e / os / android_packages_modules_Bluetooth

system/blueberry/tests/gd/cert/gd_device.py

+2 −3

Original line number	Diff line number	Diff line
		@@ -130,15 +130,14 @@ class GdDeviceBase(GdDeviceBaseCore):
		:return:
		"""
		GdDeviceBaseCore.setup(self)
		# Ensure signal port is available
		# signal port is the only port that always listen on the host machine
		asserts.assert_true(self.signal_port_available, "[%s] Failed to make signal port available" % self.label)

		# Ensure backing process is started and alive
		asserts.assert_true(self.backing_process, msg="Cannot start backing_process at " + " ".join(self.cmd))
		asserts.assert_true(
		self.is_backing_process_alive,
		msg="backing_process stopped immediately after running " + " ".join(self.cmd))
		asserts.assert_true(
		self.grpc_root_server_ready, msg="gRPC root server did not start after running " + " ".join(self.cmd))

		def get_crash_snippet_and_log_tail(self):
		GdDeviceBaseCore.get_crash_snippet_and_log_tail(self)

system/gd/cert/gd_device.py

+2 −3

Original line number	Diff line number	Diff line
		@@ -133,15 +133,14 @@ class GdDeviceBase(GdDeviceBaseCore):
		:return:
		"""
		GdDeviceBaseCore.setup(self)
		# Ensure signal port is available
		# signal port is the only port that always listen on the host machine
		asserts.assert_true(self.signal_port_available, "[%s] Failed to make signal port available" % self.label)

		# Ensure backing process is started and alive
		asserts.assert_true(self.backing_process, msg="Cannot start backing_process at " + " ".join(self.cmd))
		asserts.assert_true(
		self.is_backing_process_alive,
		msg="backing_process stopped immediately after running " + " ".join(self.cmd))
		asserts.assert_true(
		self.grpc_root_server_ready, msg="gRPC root server did not start after running " + " ".join(self.cmd))

		def get_crash_snippet_and_log_tail(self):
		GdDeviceBaseCore.get_crash_snippet_and_log_tail(self)

system/gd/cert/gd_device_lib.py

+29 −68

Original line number	Diff line number	Diff line
		@@ -18,10 +18,8 @@ from abc import ABC
		import logging
		import os
		import pathlib
		import selectors
		import shutil
		import signal
		import socket
		import subprocess

		import grpc
		@@ -33,7 +31,6 @@ from cert.logging_client_interceptor import LoggingClientInterceptor
		from cert.os_utils import get_gd_root
		from cert.os_utils import read_crash_snippet_and_log_tail
		from cert.os_utils import is_subprocess_alive
		from cert.os_utils import make_ports_available
		from cert.os_utils import TerminalColor
		from facade import rootservice_pb2_grpc as facade_rootservice_pb2_grpc
		from hal import hal_facade_pb2_grpc
		@@ -54,6 +51,8 @@ from shim.facade import facade_pb2_grpc as shim_facade_pb2_grpc
		MOBLY_CONTROLLER_CONFIG_NAME = "GdDevice"
		ACTS_CONTROLLER_REFERENCE_NAME = "gd_devices"

		GRPC_START_TIMEOUT_SEC = 15


		def create_core(configs):
		if not configs:
		@@ -141,20 +140,6 @@ class GdDeviceBaseCore(ABC):
		"""Core method to set up device for test
		:return:
		"""
		self.signal_port_available = make_ports_available([self.signal_port])
		if self.signal_port_available is not True:
		return
		# Start backing process
		with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as signal_socket:
		# Setup signaling socket
		signal_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		signal_socket.bind(("localhost", self.signal_port))
		# Allow only one incoming connection
		signal_socket.listen(1)
		# Set socket to non-blocking mode and use select() to block for timeout
		signal_socket.settimeout(0)
		signal_socket.setblocking(False)

		# Start backing process
		logging.debug("[%s] Running %s %s" % (self.type_identifier, self.label, " ".join(self.cmd)))
		self.backing_process = subprocess.Popen(
		@@ -169,45 +154,9 @@ class GdDeviceBaseCore(ABC):
		return
		self.is_backing_process_alive = is_subprocess_alive(self.backing_process)
		if not self.is_backing_process_alive:
		logging.error("[%s] backing process for %s died after starting" % (self.type_identifier, self.label))
		return

		# Wait for process to be ready
		logging.debug("[%s] Waiting for %s backing_process accept at port %d" % (self.type_identifier, self.label,
		self.signal_port))
		selector = selectors.DefaultSelector()
		selector.register(signal_socket, selectors.EVENT_READ)
		# 60 second timeout for backing process to connect to us
		timeout = 60
		ret = selector.select(timeout=timeout)
		selector.unregister(signal_socket)
		if not ret:
		logging.error("[{}] Failed to accept {} backing process connection in {} seconds".format(
		self.type_identifier, self.label, timeout))
		signal_socket.shutdown(socket.SHUT_RDWR)
		return
		conn, addr = signal_socket.accept()
		conn.setblocking(False)
		with conn:
		logging.debug("[{}] Connected {} by {}".format(self.type_identifier, self.label, addr))
		selector.register(conn, selectors.EVENT_READ)
		# Give 10 seconds for remote to disconnect from us
		timeout = 10
		ret = selector.select(timeout=timeout)
		selector.unregister(conn)
		if not ret:
		logging.warning("[{}] Failed to disconnect {} backing process in {} seconds".format(
		self.type_identifier, self.label, timeout))
		else:
		data = conn.recv(1024)
		if data:
		logging.warning("[{}] Received {} data {!r}, but not wanted".format(
		self.type_identifier, self.label, data))
		else:
		logging.debug("[{}] Received EOF to disconnect from {}".format(
		self.type_identifier, self.label))
		conn.shutdown(socket.SHUT_RDWR)
		signal_socket.shutdown(socket.SHUT_RDWR)

		self.backing_process_logger = AsyncSubprocessLogger(
		self.backing_process, [self.backing_process_log_path],
		log_to_stdout=self.verbose_mode,
		@@ -216,6 +165,18 @@ class GdDeviceBaseCore(ABC):

		# Setup gRPC management channels
		self.grpc_root_server_channel = grpc.insecure_channel("localhost:%d" % self.grpc_root_server_port)

		self.grpc_root_server_ready = False
		try:
		logging.info("[%s] Waiting to connect to gRPC root server for %s, timeout is %d seconds" %
		(self.type_identifier, self.label, GRPC_START_TIMEOUT_SEC))
		grpc.channel_ready_future(self.grpc_root_server_channel).result(timeout=GRPC_START_TIMEOUT_SEC)
		logging.info("[%s] Successfully connected to gRPC root server for %s" % (self.type_identifier, self.label))
		self.grpc_root_server_ready = True
		except grpc.FutureTimeoutError:
		logging.error("[%s] Failed to connect to gRPC root server for %s" % (self.type_identifier, self.label))
		return

		self.grpc_channel = grpc.insecure_channel("localhost:%d" % self.grpc_port)

		if self.verbose_mode:

system/gd/facade/facade_main.cc

+0 −16

Original line number	Diff line number	Diff line
		@@ -14,8 +14,6 @@
		* limitations under the License.
		*/

		#include <netinet/in.h>
		#include <sys/socket.h>
		#include <sys/types.h>
		#include <unistd.h>

		@@ -100,14 +98,12 @@ int main(int argc, const char** argv) {

		int root_server_port = 8897;
		int grpc_port = 8899;
		int signal_port = 8895;

		bluetooth::common::InitFlags::SetAllForTesting();

		const std::string arg_grpc_root_server_port = "--root-server-port=";
		const std::string arg_grpc_server_port = "--grpc-port=";
		const std::string arg_rootcanal_port = "--rootcanal-port=";
		const std::string arg_signal_port = "--signal-port=";
		const std::string arg_btsnoop_path = "--btsnoop=";
		const std::string arg_btsnooz_path = "--btsnooz=";
		const std::string arg_btconfig_path = "--btconfig=";
		@@ -139,22 +135,10 @@ int main(int argc, const char** argv) {
		auto btconfig_path = arg.substr(arg_btconfig_path.size());
		::bluetooth::os::ParameterProvider::OverrideConfigFilePath(btconfig_path);
		}
		if (arg.find(arg_signal_port) == 0) {
		auto port_number = arg.substr(arg_signal_port.size());
		signal_port = std::stoi(port_number);
		}
		}

		sigaction(SIGINT, &new_act, &old_act);
		grpc_root_server.StartServer("0.0.0.0", root_server_port, grpc_port);
		int tester_signal_socket = socket(AF_INET, SOCK_STREAM, 0);
		struct sockaddr_in addr;
		memset(&addr, 0, sizeof(addr));
		addr.sin_family = AF_INET;
		addr.sin_port = htons(signal_port);
		addr.sin_addr.s_addr = htonl(INADDR_ANY);
		connect(tester_signal_socket, (sockaddr*)&addr, sizeof(addr));
		close(tester_signal_socket);
		auto wait_thread = std::thread([] { grpc_root_server.RunGrpcLoop(); });
		wait_thread.join();

system/gd/rust/topshim/facade/src/main.rs

+0 −9

Original line number	Diff line number	Diff line
		@@ -15,7 +15,6 @@ use futures::stream::StreamExt;
		use grpcio::*;
		use log::debug;
		use nix::sys::signal;
		use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
		use std::sync::{Arc, Mutex};
		use tokio::runtime::Runtime;

		@@ -59,7 +58,6 @@ async fn async_main(rt: Arc<Runtime>, mut sigint: mpsc::UnboundedReceiver<()>) {

		let grpc_port = value_t!(matches, "grpc-port", u16).unwrap();
		let _rootcanal_port = value_t!(matches, "rootcanal-port", u16).ok();
		let signal_port = value_t!(matches, "signal-port", u16).ok();
		let env = Arc::new(Environment::new(2));

		let btif_intf = Arc::new(Mutex::new(btif::get_btinterface().unwrap()));
		@@ -83,13 +81,6 @@ async fn async_main(rt: Arc<Runtime>, mut sigint: mpsc::UnboundedReceiver<()>) {
		.build()
		.unwrap();
		server.start();
		match TcpStream::connect_timeout(
		&SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), signal_port.unwrap()),
		std::time::Duration::from_secs(2),
		) {
		Ok(_) => (),
		Err(e) => panic!("Error with connect: {}", e),
		}

		sigint.next().await;
		block_on(server.shutdown()).unwrap();