Rename asset_stream_manager to cdc_stream (#27)

Fixes #13

cdc_stream/start_service_command.cc

@@ -0,0 +1,156 @@
+// Copyright 2022 Google LLC
+//
+// 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.
+
+#include "cdc_stream/start_service_command.h"
+
+#include "cdc_stream/background_service_impl.h"
+#include "cdc_stream/local_assets_stream_manager_service_impl.h"
+#include "cdc_stream/session_management_server.h"
+#include "cdc_stream/session_manager.h"
+#include "common/clock.h"
+#include "common/grpc_status.h"
+#include "common/log.h"
+#include "common/path.h"
+#include "common/process.h"
+#include "common/status_macros.h"
+#include "lyra/lyra.hpp"
+#include "metrics/metrics.h"
+
+namespace cdc_ft {
+namespace {
+
+std::string GetLogPath(const char* log_dir, const char* log_base_name) {
+  DefaultSystemClock* clock = DefaultSystemClock::GetInstance();
+  std::string timestamp_ext = clock->FormatNow(".%Y%m%d-%H%M%S.log", false);
+  return path::Join(log_dir, log_base_name + timestamp_ext);
+}
+
+}  // namespace
+
+StartServiceCommand::StartServiceCommand(int* exit_code)
+    : BaseCommand("start-service", "Start streaming service", exit_code) {}
+StartServiceCommand::~StartServiceCommand() = default;
+
+void StartServiceCommand::RegisterCommandLineFlags(lyra::command& cmd) {
+  config_file_ = "%APPDATA%\\cdc-file-transfer\\assets_stream_manager.json";
+  cmd.add_argument(
+      lyra::opt(config_file_, "path")
+          .name("--config-file")
+          .help("Json configuration file, default: " + config_file_));
+
+  log_dir_ = "%APPDATA%\\cdc-file-transfer\\logs";
+  cmd.add_argument(
+      lyra::opt(log_dir_, "dir")
+          .name("--log-dir")
+          .help("Directory to store log files, default: " + log_dir_));
+
+  cfg_.RegisterCommandLineFlags(cmd, *this);
+}
+
+absl::Status StartServiceCommand::Run() {
+  // Set up config. Allow overriding this config with |config_file|.
+  absl::Status cfg_load_status = path::ExpandPathVariables(&config_file_);
+  cfg_load_status.Update(cfg_.LoadFromFile(config_file_));
+
+  std::unique_ptr<Log> logger;
+  ASSIGN_OR_RETURN(logger, GetLogger());
+  cdc_ft::ScopedLog scoped_log(std::move(logger));
+
+  // Log status of loaded configuration. Errors are not critical.
+  if (cfg_load_status.ok()) {
+    LOG_INFO("Successfully loaded configuration file at '%s'", config_file_);
+  } else if (absl::IsNotFound(cfg_load_status)) {
+    LOG_INFO("No configuration file found at '%s'", config_file_);
+  } else {
+    LOG_ERROR("%s", cfg_load_status.message());
+  }
+
+  std::string flags_read = cfg_.GetFlagsReadFromFile();
+  if (!flags_read.empty()) {
+    LOG_INFO(
+        "The following settings were read from the configuration file and "
+        "override the corresponding command line flags if set: %s",
+        flags_read);
+  }
+
+  std::string flag_errors = cfg_.GetFlagReadErrors();
+  if (!flag_errors.empty()) {
+    LOG_WARNING("%s", flag_errors);
+  }
+
+  LOG_DEBUG("Configuration:\n%s", cfg_.ToString());
+
+  absl::Status status = RunService();
+  if (!status.ok()) {
+    LOG_ERROR("%s", status.ToString());
+  } else {
+    LOG_INFO("Streaming service shut down successfully.");
+  }
+
+  return status;
+}
+
+absl::StatusOr<std::unique_ptr<Log>> StartServiceCommand::GetLogger() {
+  LogLevel level = Log::VerbosityToLogLevel(cfg_.session_cfg().verbosity);
+  if (cfg_.log_to_stdout()) {
+    // Log to stdout.
+    return std::make_unique<ConsoleLog>(level);
+  }
+
+  // Log to file.
+  if (!path::ExpandPathVariables(&log_dir_).ok() ||
+      !path::CreateDirRec(log_dir_).ok()) {
+    return absl::InvalidArgumentError(
+        absl::StrFormat("Failed to create log directory '%s'", log_dir_));
+  }
+
+  return std::make_unique<FileLog>(
+      level, GetLogPath(log_dir_.c_str(), "assets_stream_manager").c_str());
+}
+
+// Runs the session management service and returns when it finishes.
+absl::Status StartServiceCommand::RunService() {
+  WinProcessFactory process_factory;
+  metrics::MetricsService metrics_service;
+
+  SessionManager session_manager(cfg_.session_cfg(), &process_factory,
+                                 &metrics_service);
+  BackgroundServiceImpl background_service;
+  LocalAssetsStreamManagerServiceImpl session_service(
+      &session_manager, &process_factory, &metrics_service);
+
+  SessionManagementServer sm_server(&session_service, &background_service,
+                                    &session_manager);
+  background_service.SetExitCallback(
+      [&sm_server]() { return sm_server.Shutdown(); });
+
+  if (!cfg_.dev_src_dir().empty()) {
+    localassetsstreammanager::StartSessionRequest request;
+    request.set_workstation_directory(cfg_.dev_src_dir());
+    request.set_user_host(cfg_.dev_target().user_host);
+    request.set_mount_dir(cfg_.dev_target().mount_dir);
+    request.set_port(cfg_.dev_target().ssh_port);
+    request.set_ssh_command(cfg_.dev_target().ssh_command);
+    request.set_scp_command(cfg_.dev_target().scp_command);
+    localassetsstreammanager::StartSessionResponse response;
+    RETURN_ABSL_IF_ERROR(
+        session_service.StartSession(nullptr, &request, &response));
+  }
+  RETURN_IF_ERROR(
+      sm_server.Start(SessionManagementServer::kDefaultServicePort));
+  sm_server.RunUntilShutdown();
+  return absl::OkStatus();
+}
+
+}  // namespace cdc_ft