Don't start the webrtc_operator binary

This is no longer supported since this version of run_cvd runs in hosts
that have the signaling server.

Author: jemoreira

base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp

@@ -205,28 +205,11 @@ DEFINE_vec(start_webrtc, fmt::format("{}", CF_DEFAULTS_START_WEBRTC),
            "Whether to start the webrtc process.");
 
 DEFINE_vec(webrtc_assets_dir, CF_DEFAULTS_WEBRTC_ASSETS_DIR,
-              "[Experimental] Path to WebRTC webpage assets.");
-
-DEFINE_string(webrtc_certs_dir, CF_DEFAULTS_WEBRTC_CERTS_DIR,
-              "[Experimental] Path to WebRTC certificates directory.");
-
-DEFINE_bool(
-    // The actual default for this flag is set with SetCommandLineOption() in
-    // GetGuestConfigsAndSetDefaults() at the end of this file.
-    start_webrtc_sig_server, CF_DEFAULTS_START_WEBRTC_SIG_SERVER,
-    "Whether to start the webrtc signaling server. This option only applies to "
-    "the first instance, if multiple instances are launched they'll share the "
-    "same signaling server, which is owned by the first one.");
+           "Path to WebRTC webpage assets.");
 
 DEFINE_string(webrtc_sig_server_addr, CF_DEFAULTS_WEBRTC_SIG_SERVER_ADDR,
               "The address of the webrtc signaling server.");
 
-DEFINE_int32(
-    webrtc_sig_server_port, CF_DEFAULTS_WEBRTC_SIG_SERVER_PORT,
-    "The port of the signaling server if started outside of this launch. If "
-    "-start_webrtc_sig_server is given it will choose 8443+instance_num1-1 and "
-    "this parameter is ignored.");
-
 // TODO (jemoreira): We need a much bigger range to reliably support several
 // simultaneous connections.
 DEFINE_vec(tcp_port_range, CF_DEFAULTS_TCP_PORT_RANGE,
@@ -237,20 +220,6 @@ DEFINE_vec(udp_port_range, CF_DEFAULTS_UDP_PORT_RANGE,
               "The minimum and maximum UDP port numbers to allocate for ICE "
               "candidates as 'min:max'. To use any port just specify '0:0'");
 
-DEFINE_string(webrtc_sig_server_path, CF_DEFAULTS_WEBRTC_SIG_SERVER_PATH,
-              "The path section of the URL where the device should be "
-              "registered with the signaling server.");
-
-DEFINE_bool(
-    webrtc_sig_server_secure, CF_DEFAULTS_WEBRTC_SIG_SERVER_SECURE,
-    "Whether the WebRTC signaling server uses secure protocols (WSS vs WS).");
-
-DEFINE_bool(verify_sig_server_certificate,
-            CF_DEFAULTS_VERIFY_SIG_SERVER_CERTIFICATE,
-            "Whether to verify the signaling server's certificate with a "
-            "trusted signing authority (Disallow self signed certificates). "
-            "This is ignored if an insecure server is configured.");
-
 DEFINE_vec(
     webrtc_device_id, CF_DEFAULTS_WEBRTC_DEVICE_ID,
     "The for the device to register with the signaling server. Every "

base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h

@@ -97,24 +97,14 @@ DECLARE_vec(start_webrtc);
 
 DECLARE_vec(webrtc_assets_dir);
 
-DECLARE_string(webrtc_certs_dir);
-
 DECLARE_bool(start_webrtc_sig_server);
 
 DECLARE_string(webrtc_sig_server_addr);
 
-DECLARE_int32(webrtc_sig_server_port);
-
 DECLARE_vec(tcp_port_range);
 
 DECLARE_vec(udp_port_range);
 
-DECLARE_string(webrtc_sig_server_path);
-
-DECLARE_bool(webrtc_sig_server_secure);
-
-DECLARE_bool(verify_sig_server_certificate);
-
 DECLARE_vec(webrtc_device_id);
 
 DECLARE_vec(uuid);

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc

@@ -84,8 +84,6 @@ using vm_manager::GetVmManager;
 
 namespace {
 
-constexpr auto HOST_OPERATOR_SOCKET_PATH = "/run/cuttlefish/operator";
-
 std::pair<uint16_t, uint16_t> ParsePortRange(const std::string& flag) {
   static const std::regex rgx("[0-9]+:[0-9]+");
   CHECK(std::regex_match(flag, rgx))
@@ -444,14 +442,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
 
   tmp_config_obj.set_gem5_debug_flags(FLAGS_gem5_debug_flags);
 
-  // streaming, webrtc setup
-  tmp_config_obj.set_webrtc_certs_dir(FLAGS_webrtc_certs_dir);
-  tmp_config_obj.set_sig_server_secure(FLAGS_webrtc_sig_server_secure);
-  // Note: This will be overridden if the sig server is started by us
-  tmp_config_obj.set_sig_server_port(FLAGS_webrtc_sig_server_port);
   tmp_config_obj.set_sig_server_address(FLAGS_webrtc_sig_server_addr);
-  tmp_config_obj.set_sig_server_path(FLAGS_webrtc_sig_server_path);
-  tmp_config_obj.set_sig_server_strict(FLAGS_verify_sig_server_certificate);
 
   tmp_config_obj.set_enable_metrics(FLAGS_report_anonymous_usage_stats);
   // TODO(moelsherif): Handle this flag (set_metrics_binary) in the future
@@ -1212,28 +1203,13 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
 
     // end of streaming, webrtc setup
 
-    instance.set_start_webrtc_signaling_server(false);
-
     CF_EXPECT(Contains(num_to_webrtc_device_id_flag_map, num),
               "Error in looking up num to webrtc_device_id_flag_map");
     instance.set_webrtc_device_id(num_to_webrtc_device_id_flag_map[num]);
 
-    if (!is_first_instance || !start_webrtc_vec[instance_index]) {
-      // Only the first instance starts the signaling server or proxy
-      instance.set_start_webrtc_signaling_server(false);
-      instance.set_start_webrtc_sig_server_proxy(false);
-    } else {
-      auto port = 8443 + num - 1;
-      // Change the signaling server port for all instances
-      tmp_config_obj.set_sig_server_port(port);
-      // Either the signaling server or the proxy is started, never both
-      instance.set_start_webrtc_signaling_server(FLAGS_start_webrtc_sig_server);
-      // The proxy is only started if the host operator is available
-      instance.set_start_webrtc_sig_server_proxy(
-          cuttlefish::FileIsSocket(HOST_OPERATOR_SOCKET_PATH) &&
-          !FLAGS_start_webrtc_sig_server);
-    }
-
+    auto port = 8443 + num - 1;
+    // Change the signaling server port for all instances
+    tmp_config_obj.set_sig_server_proxy_port(port);
     instance.set_start_netsim(is_first_instance && is_any_netsim);
 
     instance.set_start_rootcanal(is_first_instance && !is_bt_netsim &&
@@ -1570,10 +1546,6 @@ Result<void> SetFlagDefaultsForVmm(
     const std::vector<GuestConfig>& guest_configs,
     const SystemImageDirFlag& system_image_dir,
     const VmManagerFlag& vm_manager_flag) {
-  auto instance_nums =
-      CF_EXPECT(InstanceNumsCalculator().FromGlobalGflags().Calculate());
-  int32_t instances_size = instance_nums.size();
-
   // get flag default values and store into map
   auto name_to_default_value = CurrentFlagsToDefaultValue();
 
@@ -1594,30 +1566,6 @@ Result<void> SetFlagDefaultsForVmm(
     case VmmMode::kUnknown:
       return CF_ERR("Unknown VM manager");
   }
-  if (vm_manager_flag.Mode() != VmmMode::kGem5) {
-    // After SetCommandLineOptionWithMode in SetDefaultFlagsForCrosvm/Qemu,
-    // default flag values changed, need recalculate name_to_default_value
-    name_to_default_value = CurrentFlagsToDefaultValue();
-    std::vector<bool> start_webrtc_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(
-        start_webrtc));
-    bool start_webrtc = false;
-    for(bool value : start_webrtc_vec) {
-      start_webrtc |= value;
-    }
-
-    auto host_operator_present =
-        cuttlefish::FileIsSocket(HOST_OPERATOR_SOCKET_PATH);
-    // The default for starting signaling server depends on whether or not webrtc
-    // is to be started and the presence of the host orchestrator.
-    SetCommandLineOptionWithMode(
-        "start_webrtc_sig_server",
-        start_webrtc && !host_operator_present ? "true" : "false",
-        google::FlagSettingMode::SET_FLAGS_DEFAULT);
-    SetCommandLineOptionWithMode(
-        "webrtc_sig_server_addr",
-        host_operator_present ? HOST_OPERATOR_SOCKET_PATH : "0.0.0.0",
-        google::FlagSettingMode::SET_FLAGS_DEFAULT);
-  }
 
   SetDefaultFlagsForOpenwrt(guest_configs[0].target_arch);
 

base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h

@@ -220,17 +220,11 @@
 
 // Streaming default parameters
 #define CF_DEFAULTS_START_WEBRTC false
-#define CF_DEFAULTS_START_WEBRTC_SIG_SERVER true
 #define CF_DEFAULTS_WEBRTC_DEVICE_ID "cvd-{num}"
-#define CF_DEFAULTS_VERIFY_SIG_SERVER_CERTIFICATE false
 #define CF_DEFAULTS_WEBRTC_ASSETS_DIR \
   cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/assets")
-#define CF_DEFAULTS_WEBRTC_CERTS_DIR \
-  cuttlefish::DefaultHostArtifactsPath("usr/share/webrtc/certs")
-#define CF_DEFAULTS_WEBRTC_SIG_SERVER_ADDR CF_DEFAULTS_DYNAMIC_STRING
+#define CF_DEFAULTS_WEBRTC_SIG_SERVER_ADDR "/run/cuttlefish/operator"
 #define CF_DEFAULTS_WEBRTC_SIG_SERVER_PATH "/register_device"
-#define CF_DEFAULTS_WEBRTC_SIG_SERVER_PORT 443
-#define CF_DEFAULTS_WEBRTC_SIG_SERVER_SECURE true
 #define CF_DEFAULTS_TCP_PORT_RANGE "15550:15599"
 #define CF_DEFAULTS_UDP_PORT_RANGE "15550:15599"
 

base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/streaming.dot

@@ -6,8 +6,6 @@ streaming--verify_sig_server_certificate
 streaming--assets_dir
 streaming--certs_dir
 streaming--sig_server_addr
-streaming--sig_server_path
-streaming--sig_server_port
 streaming--sig_server_secure
 streaming--tcp_port_range
 streaming--udp_port_range

base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp

@@ -219,40 +219,24 @@ class WebRtcServer : public virtual CommandSource,
         sensors_socket_pair_(sensors_socket_pair) {}
   // DiagnosticInformation
   std::vector<std::string> Diagnostics() const override {
-    if (!Enabled() ||
-        !(config_.ForDefaultInstance().start_webrtc_sig_server() ||
-          config_.ForDefaultInstance().start_webrtc_sig_server_proxy())) {
-      // When WebRTC is enabled but an operator other than the one launched by
-      // run_cvd is used there is no way to know the url to which to point the
-      // browser to.
+    if (!Enabled()) {
       return {};
     }
     std::ostringstream out;
     out << "Point your browser to https://localhost:"
-        << config_.sig_server_port() << " to interact with the device.";
+        << config_.sig_server_proxy_port() << " to interact with the device.";
     return {out.str()};
   }
 
   // CommandSource
   Result<std::vector<MonitorCommand>> Commands() override {
     std::vector<MonitorCommand> commands;
-    if (instance_.start_webrtc_sig_server()) {
-      Command sig_server(WebRtcSigServerBinary());
-      sig_server.AddParameter("-assets_dir=", instance_.webrtc_assets_dir());
-      sig_server.AddParameter("-use_secure_http=",
-                              config_.sig_server_secure() ? "true" : "false");
-      if (!config_.webrtc_certs_dir().empty()) {
-        sig_server.AddParameter("-certs_dir=", config_.webrtc_certs_dir());
-      }
-      sig_server.AddParameter("-http_server_port=", config_.sig_server_port());
-      commands.emplace_back(std::move(sig_server));
-    }
 
-    if (instance_.start_webrtc_sig_server_proxy()) {
-      Command sig_proxy(WebRtcSigServerProxyBinary());
-      sig_proxy.AddParameter("-server_port=", config_.sig_server_port());
-      commands.emplace_back(std::move(sig_proxy));
-    }
+    // Start a TCP proxy to make the host signaling server available on the
+    // legacy port.
+    Command sig_proxy(WebRtcSigServerProxyBinary());
+    sig_proxy.AddParameter("-server_port=", config_.sig_server_proxy_port());
+    commands.emplace_back(std::move(sig_proxy));
 
     auto stopper = [webrtc_controller = webrtc_controller_]() mutable {
       (void)webrtc_controller.SendStopRecordingCommand();
@@ -263,13 +247,6 @@ class WebRtcServer : public virtual CommandSource,
 
     webrtc.UnsetFromEnvironment("http_proxy");
     sockets_.AppendCommandArguments(webrtc);
-    // Currently there is no way to ensure the signaling server will already
-    // have bound the socket to the port by the time the webrtc process runs
-    // (the common technique of doing it from the launcher is not possible here
-    // as the server library being used creates its own sockets). However, this
-    // issue is mitigated slightly by doing some retrying and backoff in the
-    // webrtc process when connecting to the websocket, so it shouldn't be an
-    // issue most of the time.
     webrtc.AddParameter("--command_fd=", webrtc_controller_.GetClientSocket());
     webrtc.AddParameter("-kernel_log_events_fd=", kernel_log_events_pipe_);
     webrtc.AddParameter("-client_dir=",

base/cvd/cuttlefish/host/commands/status/main.cc

@@ -79,6 +79,7 @@ std::string CalcWebAccessUrl(const WebAccessUrlParam& web_access_url_param) {
   if (!FileIsSocket(web_access_url_param.sig_server_addr)) {
     return "";
   }
+  // 1443 is the port of the global webrtc "operator" service
   return std::string("https://") + "localhost" + ":" + "1443" + "/devices/" +
          web_access_url_param.webrtc_device_id + "/files" + "/client.html";
 }
@@ -94,12 +95,10 @@ Json::Value PopulateDevicesInfoFromInstance(
   device_info["assembly_dir"] = config.assembly_dir();
   device_info["webrtc_device_id"] = webrtc_device_id;
   device_info["instance_dir"] = instance_config.instance_dir();
-  // 1443 is the port of the global webrtc "operator" service
   device_info["web_access"] =
       CalcWebAccessUrl({.sig_server_addr = config.sig_server_address(),
                         .webrtc_device_id = webrtc_device_id});
   device_info["adb_serial"] = instance_config.adb_ip_and_port();
-  device_info["webrtc_port"] = std::to_string(config.sig_server_port());
   for (int i = 0; i < instance_config.display_configs().size(); i++) {
     device_info["displays"][i] =
         std::to_string(instance_config.display_configs()[i].width) + " x " +

base/cvd/cuttlefish/host/frontend/webrtc/libdevice/server_connection.cpp

@@ -17,6 +17,7 @@
 
 #include <atomic>
 #include <mutex>
+#include <string>
 #include <thread>
 
 #include <android-base/logging.h>
@@ -54,10 +55,10 @@ class UnixServerConnection : public ServerConnection {
 };
 
 std::unique_ptr<ServerConnection> ServerConnection::Connect(
-    const ServerConfig& conf,
+    const std::string& operator_path,
     std::weak_ptr<ServerConnectionObserver> observer) {
   std::unique_ptr<ServerConnection> ret(
-      new UnixServerConnection(conf.addr, observer));
+      new UnixServerConnection(operator_path, observer));
   ret->Connect();
   return ret;
 }

base/cvd/cuttlefish/host/frontend/webrtc/libdevice/server_connection.h

@@ -25,22 +25,6 @@
 namespace cuttlefish {
 namespace webrtc_streaming {
 
-struct ServerConfig {
-  enum class Security {
-    kInsecure,
-    kAllowSelfSigned,
-    kStrict,
-  };
-
-  // The ip address or domain name of the operator server.
-  std::string addr;
-  int port;
-  // The path component of the operator server's register url.
-  std::string path;
-  // The security level to use when connecting to the operator server.
-  Security security;
-};
-
 class ServerConnectionObserver {
  public:
   virtual ~ServerConnectionObserver() = default;
@@ -62,7 +46,7 @@ class ServerConnectionObserver {
 class ServerConnection {
  public:
   static std::unique_ptr<ServerConnection> Connect(
-      const ServerConfig& conf,
+      const std::string& operator_path,
       std::weak_ptr<ServerConnectionObserver> observer);
 
   // Destroying the connection will disconnect from the signaling server and

base/cvd/cuttlefish/host/frontend/webrtc/libdevice/streamer.cpp

@@ -38,6 +38,7 @@
 #include "cuttlefish/host/frontend/webrtc/libdevice/audio_track_source_impl.h"
 #include "cuttlefish/host/frontend/webrtc/libdevice/camera_streamer.h"
 #include "cuttlefish/host/frontend/webrtc/libdevice/client_handler.h"
+#include "cuttlefish/host/frontend/webrtc/libdevice/server_connection.h"
 #include "cuttlefish/host/frontend/webrtc/libdevice/video_track_source_impl.h"
 #include "cuttlefish/host/frontend/webrtc_operator/constants/signaling_constants.h"
 
@@ -388,7 +389,7 @@ void Streamer::Impl::Register(std::weak_ptr<OperatorObserver> observer) {
   // the registration will take place
   if (!server_connection_) {
     server_connection_ =
-        ServerConnection::Connect(config_.operator_server, weak_from_this());
+        ServerConnection::Connect(config_.operator_path, weak_from_this());
   } else {
     // in case connection attempt is retried, just call Reconnect().
     // Recreating server_connection_ object will destroy existing WSConnection